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,

    25

            help="Force updates, even for fresh items")

    29

    30

    return parser

    31

    32

def build_config (options) :

    33

    """

    34

        Build a configuration object with the given options

    35

    """

    36

    37

    # build default config

    38

    config = config_module.Configuration()

    39

    40

    # apply options

    41

    if options.gallery_path :

    42

        config.gallery_path = options.gallery_path

    43

    44

    if options.read_only :

    45

        config.read_only = True

    46

    47

    if options.force_update :

    48

        config.force_update = True

    49

    53

    # XXX: load config file(s)

    54

    55

    return config

    56

    57

def load_gallery (config) :

    58

    """

    59

        Create the Gallery object that we are manipulating

    60

    """

    61

    62

    # read path from config

    63

    return gallery.Gallery(config.gallery_path, config)

    64

    65

def load_command (config, args) :

    66

    """

    67

        Figure out what command to run and with what args

    68

    """

    69

    70

    # XXX: hardcoded

    71

    return commands.main, args, {}

    72

    73

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

    74

    """

    75

        Run the given command

    76

    """

    77

    78

    # setup the command execution context

    79

    command_ctx = command.setup(config, gallery)

    80

    81

    try :

    82

        # run it

    83

        return command_ctx(*args, **kwargs)

    84

    85

    except :

    86

        command_ctx.handle_error()

    87

    88

def main (argv) :

    89

    """

    90

        Main entry point

    91

    """

    92

    93

    ## load commands

    94

    #commands = load_commands()

    95

    96

    # build optparser

    97

    parser = option_parser(argv[0])

    98

    99

    # parse the given argv

   100

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

   101

   102

    # build our config

   103

    config = build_config(options)

   104

   105

    # open gallery

   106

    gallery = load_gallery(config)

   107

   108

    # figure out what command to run

   109

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

   110

   111

    # run the selected command

   112

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

   113

   114

    if ret is None :

   115

        # success

   116

        return 0

   117

   118

    else :

   119

        # exit with error code

   120

        assert isinstance(ret, int)

   121

        return ret

   122