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('-R', "--read-only",      dest='read_only',  action="store_true", default=False,

    22

            help="Do not attempt to modify the gallery")

    23

    24

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

    38

    39

    return parser

    40

    41

def build_config (options) :

    42

    """

    43

        Build a configuration object with the given options

    44

    """

    45

    46

    # build default config

    47

    config = config_module.Configuration()

    48

    49

    # apply options

    50

    if options.gallery_path :

    51

        config.gallery_path = options.gallery_path

    52

    53

    if options.read_only :

    54

        config.read_only = True

    55

    56

    if options.force_update :

    71

    72

    # XXX: load config file(s)

    73

    74

    return config

    75

    76

def load_gallery (config) :

    77

    """

    78

        Create the Gallery object that we are manipulating

    79

    """

    80

    81

    # read path from config

    82

    return gallery.Gallery(config.gallery_path, config)

    83

    84

def load_command (config, args) :

    85

    """

    86

        Figure out what command to run and with what args

    87

    """

    88

    89

    # XXX: hardcoded

    90

    return commands.main, args, {}

    91

    92

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

    93

    """

    94

        Run the given command

    95

    """

    96

    97

    # setup the command execution context

    98

    command_ctx = command.setup(config, gallery)

    99

   100

    # run with error handling

   101

    return command_ctx.run()

   102

   103

def main (argv) :

   104

    """

   105

        Main entry point

   106

    """

   107

   108

    ## load commands

   109

    #commands = load_commands()

   110

   111

    # build optparser

   112

    parser = option_parser(argv[0])

   113

   114

    # parse the given argv

   115

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

   116

   117

    # build our config

   118

    config = build_config(options)

   119

   120

    # open gallery

   121

    gallery = load_gallery(config)

   122

   123

    # figure out what command to run

   124

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

   125

   126

    # run the selected command

   127

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

   128

   129

    if ret is None :

   130

        # success

   131

        return 0

   132

   133

    else :

   134

        # exit with error code

   135

        assert isinstance(ret, int)

   136

        return ret

   137