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

    26

    27

    return parser

    28

    29

def build_config (options) :

    30

    """

    31

        Build a configuration object with the given options

    32

    """

    33

    34

    # build default config

    35

    config = config_module.Configuration()

    36

    37

    # apply options

    38

    if options.gallery_path :

    39

        config.gallery_path = options.gallery_path

    40

    41

    if options.read_only :

    42

        config.read_only = True

    43

    47

    # XXX: load config file(s)

    48

    49

    return config

    50

    51

def load_gallery (config) :

    52

    """

    53

        Create the Gallery object that we are manipulating

    54

    """

    55

    56

    # read path from config

    57

    return gallery.Gallery(config.gallery_path, config)

    58

    59

def load_command (config, args) :

    60

    """

    61

        Figure out what command to run and with what args

    62

    """

    63

    64

    # XXX: hardcoded

    65

    return commands.main, args, {}

    66

    67

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

    68

    """

    69

        Run the given command

    70

    """

    71

    72

    # setup the command execution context

    73

    command_ctx = command.setup(config, gallery)

    74

    75

    try :

    76

        # run it

    77

        return command_ctx(*args, **kwargs)

    78

    79

    except :

    80

        command_ctx.handle_error()

    81

    82

def main (argv) :

    83

    """

    84

        Main entry point

    85

    """

    86

    87

    ## load commands

    88

    #commands = load_commands()

    89

    90

    # build optparser

    91

    parser = option_parser(argv[0])

    92

    93

    # parse the given argv

    94

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

    95

    96

    # build our config

    97

    config = build_config(options)

    98

    99

    # open gallery

   100

    gallery = load_gallery(config)

   101

   102

    # figure out what command to run

   103

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

   104

   105

    # run the selected command

   106

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

   107

   108

    if ret is None :

   109

        # success

   110

        return 0

   111

   112

    else :

   113

        # exit with error code

   114

        assert isinstance(ret, int)

   115

        return ret

   116