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", dest='gallery_path', help="Use DIR as the Gallery path [default: CWD]", metavar='DIR', default=None)

    19

    parser.add_option('-R', "--read-only", dest='read_only', help="Do not attempt to modify the gallery", action="store_true", default=False)

    20

    21

    return parser

    22

    23

def build_config (options) :

    24

    """

    25

        Build a configuration object with the given options

    26

    """

    27

    28

    # build default config

    29

    config = config_module.Configuration()

    30

    31

    # apply options

    32

    if options.gallery_path :

    33

        config.gallery_path = options.gallery_path

    34

    35

    if options.read_only :

    36

        config.read_only = True

    37

    38

    # XXX: load config file(s)

    39

    40

    return config

    41

    42

def load_gallery (config) :

    43

    """

    44

        Create the Gallery object that we are manipulating

    45

    """

    46

    47

    # read path from config

    48

    return gallery.Gallery(config.gallery_path, config)

    49

    50

def load_command (config, args) :

    51

    """

    52

        Figure out what command to run and with what args

    53

    """

    54

    55

    # XXX: hardcoded

    56

    return commands.main, args, {}

    57

    58

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

    59

    """

    60

        Run the given command

    61

    """

    62

    63

    # setup the command execution context

    64

    command_ctx = command.setup(config, gallery)

    65

    66

    try :

    67

        # run it

    68

        return command_ctx(*args, **kwargs)

    69

    70

    except :

    71

        command_ctx.handle_error()

    72

    73

def main (argv) :

    74

    """

    75

        Main entry point

    76

    """

    77

    78

    ## load commands

    79

    #commands = load_commands()

    80

    81

    # build optparser

    82

    parser = option_parser(argv[0])

    83

    84

    # parse the given argv

    85

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

    86

    87

    # build our config

    88

    config = build_config(options)

    89

    90

    # open gallery

    91

    gallery = load_gallery(config)

    92

    93

    # figure out what command to run

    94

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

    95

    96

    # run the selected command

    97

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

    98

    99

    if ret is None :

   100

        # success

   101

        return 0

   102

   103

    else :

   104

        # exit with error code

   105

        assert isinstance(ret, int)

   106

        return ret

   107