1

"""

     2

    Main entry point for the command-line interface

     3

"""

     4

     5

import gallery, commands, config

     6

     7

from optparse import OptionParser

     8

import os.path

     9

    10

def build_config () :

    11

    """

    12

        Build the default configuration to use

    13

    """

    14

    15

    return config.Configuration()

    16

    17

def option_parser (exec_name) :

    18

    """

    19

        Build the OptionParser that we use

    20

    """

    21

    22

    parser = OptionParser(prog=exec_name, description="Degal - A photo gallery", version="???")

    23

    24

    parser.add_option('-C', "--config",         metavar='PATH', dest="_load_config_path",

    25

            help="Load configuration from PATH")

    26

    27

    parser.add_option('-H', "--gallery-path",   metavar='DIR',

    28

            help="Use DIR as the Gallery path instead of the CWD")

    29

    30

    parser.add_option('-F', "--force-update",   action="store_true",

    31

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

    32

    33

    parser.add_option("--force-thumb",          action="store_true",

    34

            help="Force-update thumbnails")

    35

    36

    parser.add_option("--force-html",           action="store_true",

    37

            help="Force-update .html files")

    38

    39

    parser.add_option("--with-exif",            action="store_true",

    40

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

    44

    45

    parser.add_option('-c', "--thread-count",   metavar='COUNT', type="int",

    46

            help="Use COUNT threads for concurrent tasks")

    47

    48

    parser.add_option('-d', "--debug",          action="store_const", dest="log_level", const=config.logging.DEBUG,

    49

            help="Show debug output")

    50

    51

    parser.add_option('-q', "--quiet",          action="store_const", dest="log_level", const=config.logging.WARN,

    52

            help="Reduced output (only warnings)")

    53

    54

    return parser

    55

    56

def parse_args (config, parser, args) :

    57

    """

    58

        Parse command-line options/arguments.

    59

    60

        Returns the remaining positional arguments.

    61

    """

    62

    63

    # parse the given arguments, storing output directly in the config

    64

    _, args = parser.parse_args(args=args, values=config)

    65

    66

    # return the posargs

    67

    return args

    68

    69

def postprocess_config (config) :

    70

    """

    71

        Post-process our Configuration after our command-line arguments have been parsed.

    72

    73

        This will attempt to load any additional configuration.

    74

    """

    75

    76

    # figure out what, if any, path to import

    77

    if hasattr(config, '_load_config_path') :

    78

        path = config._load_config_path

    79

    80

    elif os.path.exists('degal.cfg') :

    81

        path = 'degal.cfg'

    82

    83

    else :

    84

        return

    85

    86

    # import it

    87

    config.import_file(path)

    88

    89

def load_gallery (config) :

    90

    """

    91

        Create the Gallery object that we are manipulating

    92

    """

    93

    94

    # read path from config

    95

    return gallery.Gallery(config.gallery_path, config)

    96

    97

def load_command (config, args) :

    98

    """

    99

        Figure out what command to run and with what args

   100

    """

   101

   102

    # XXX: hardcoded

   103

    return commands.main, args, {}

   104

   105

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

   106

    """

   107

        Run the given command

   108

    """

   109

   110

    # setup the command execution context

   111

    command_ctx = command.setup(config, gallery)

   112

   113

    # run with error handling

   114

    return command_ctx.run()

   115

   116

def main (argv) :

   117

    """

   118

        Main entry point

   119

    """

   120

   121

    ## load commands

   122

    #commands = load_commands()

   123

   124

    # build our default config

   125

    config = build_config()

   126

   127

    # build optparser

   128

    parser = option_parser(argv[0])

   129

   130

    # parse the args into our config

   131

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

   132

   133

    # postprocess

   134

    postprocess_config(config)

   135

   136

    # open gallery

   137

    gallery = load_gallery(config)

   138

   139

    # figure out what command to run

   140

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

   141

   142

   143

   144

    # run the selected command

   145

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

   146

   147

   148

    if ret is None :

   149

        # success

   150

        return 0

   151

   152

    else :

   153

        # exit with error code

   154

        assert isinstance(ret, int)

   155

        return ret

   156