1

"""

     2

    Main entry point for the command-line interface

     3

"""

     4

     5

import gallery, commands, config as config_module

     6

     7

from optparse import OptionParser

     8

     9

def option_parser (command_name) :

    10

    """

    11

        Build the OptionParser that we use

    12

    """

    13

    14

    # create parser using the given command

    15

    parser = OptionParser(prog=command_name)

    16

    17

    # define options

    18

    parser.add_option('-G', "--gallery-path",   metavar='DIR',  dest='gallery_path',    default=None,

    19

            help="Use DIR as the Gallery path [default: CWD]")

    20

    21

    parser.add_option('-F', "--force-update",   dest='force_update', action="store_true", default=False,

    22

            help="--force-thumb + --force-html")

    23

    24

    parser.add_option("--force-thumb",          dest='force_thumb', action="store_true", default=False,

    25

            help="Force-update all thumbnails")

    26

    27

    parser.add_option("--force-html",           dest='force_html', action="store_true", default=False,

    28

            help="Force-update all .html files")

    29

    30

    parser.add_option("--with-exif",            dest='exif_enabled', action="store_true", default=None,

    31

            help="Include Exif metadata in updated .html files")

    32

    36

    parser.add_option('-d', "--debug",          dest='debug', action="store_true", default=False,

    37

            help="Show debug output")

    38

    39

    parser.add_option('-q', "--quiet",           dest='quiet', action="store_true", default=False,

    40

            help="Reduced output")

    41

    42

    return parser

    43

    44

def build_config (options) :

    45

    """

    46

        Build a configuration object with the given options

    47

    """

    48

    49

    # build default config

    50

    config = config_module.Configuration()

    51

    52

    # apply options

    53

    if options.gallery_path :

    54

        config.gallery_path = options.gallery_path

    55

    56

    if options.force_update :

    57

        config.force_html = True

    58

        config.force_thumb = True

    59

    60

    if options.force_thumb :

    61

        config.force_thumb = True

    62

    63

    if options.force_html :

    64

        config.force_html = True

    65

    66

    if options.exif_enabled is not None :

    67

        config.exif_enabled = options.exif_enabled

    68

    72

    if options.debug :

    73

        config.log_level = config_module.logging.DEBUG

    74

    75

    if options.quiet :

    76

        config.log_level = config_module.logging.WARN

    77

    78

    # XXX: load config file(s)

    79

    80

    return config

    81

    82

def load_gallery (config) :

    83

    """

    84

        Create the Gallery object that we are manipulating

    85

    """

    86

    87

    # read path from config

    88

    return gallery.Gallery(config.gallery_path, config)

    89

    90

def load_command (config, args) :

    91

    """

    92

        Figure out what command to run and with what args

    93

    """

    94

    95

    # XXX: hardcoded

    96

    return commands.main, args, {}

    97

    98

def run_command (config, gallery, command, args, kwargs) :

    99

    """

   100

        Run the given command

   101

    """

   102

   103

    # setup the command execution context

   104

    command_ctx = command.setup(config, gallery)

   105

   106

    # run with error handling

   107

    return command_ctx.run()

   108

   109

def main (argv) :

   110

    """

   111

        Main entry point

   112

    """

   113

   114

    ## load commands

   115

    #commands = load_commands()

   116

   117

    # build optparser

   118

    parser = option_parser(argv[0])

   119

   120

    # parse the given argv

   121

    options, args = parser.parse_args(argv[1:])

   122

   123

    # build our config

   124

    config = build_config(options)

   125

   126

    # open gallery

   127

    gallery = load_gallery(config)

   128

   129

    # figure out what command to run

   130

    command, args, kwargs = load_command(config, args)

   131

   132

    # run the selected command

   133

    ret = run_command(config, gallery, command, args, kwargs)

   134

   135

    if ret is None :

   136

        # success

   137

        return 0

   138

   139

    else :

   140

        # exit with error code

   141

        assert isinstance(ret, int)

   142

        return ret

   143