Synnefo » ./kamaki

#    1. Get a command string         DONE

#    2. Parse out some Arguments     DONE

#        a. We need an Argument "library" for each command-level     DONE

#        b. Handle arg errors     

#    3. Retrieve and validate command_sequence

#        a. For faster responses, first command can be chosen from

#            a prefixed list of names, loaded from the config file

#        b. Normally, each 1st level command has a file to read

#            command specs from. Load command_specs in this file

#            i. A dict with command specs is created

#                e.g. {'store':{'list':{'all', None}, 'info'}, 'server':{'list', 'info'}}

#                but in this case there will be only 'store', or 'server', etc.

#        c. Now, loop over the other parsed terms and check them against the commands

#            i. That will produce a path of the form ['store', 'list' 'all']

#        d. Catch syntax errors

#    4. Instaciate object to exec

#        a. For path ['store', 'list', 'all'] instatiate store_list_all()

#    5. Parse out some more Arguments 

#        a. Each command path has an "Argument library" to check your args against

#    6. Call object.main() and catch ClientErrors

#        a. Now, there are some command-level syntax errors that we should catch

#            as syntax errors? Maybe! Why not?

#    1. Load ALL available command specs in advance

#    2. Iimport cmd (and run it ?)

#    3. There is probably a way to tell cmd of the command paths you support.

#    4. If cmd does not support it, for the sellected path call parse out stuff

#        as in One-command

#    5. Instatiate, parse_out and run object like in One-command

#    6. Run object.main() . Again, catch ClientErrors and, probably, syntax errors

    @property 

    def value(self):

        return super(self.__class__, self).value

    @value.setter

    def value(self, config_file):

        self._value = Config(config_file) if config_file is not None else Config()

    def get(self, group, term):

        return self.value.get(group, term)

    def get_groups(self):

        return self.value.apis()

    def __init__(self, config_arg, help='', parsed_name=None, default=None):

        super(self.__class__, self).__init__(1, help, parsed_name, default)

        self._config_arg = config_arg

    @property 

    def value(self):

        return super(self.__class__, self).value

    @value.setter

    def value(self, options):

        if options == self.default:

            return

        options = [unicode(options)] if not isinstance(options, list) else options

        for option in options:

            keypath, sep, val = option.partition('=')

            if not sep:

                raise CLISyntaxError(details='Missing = between key and value: -o section.key=val')

            section, sep, key = keypath.partition('.')

            if not sep:

                raise CLISyntaxError(details='Missing . between section and key: -o section.key=val')

        self._config_arg.value.override(section.strip(), key.strip(), val.strip())

class FlagArgument(Argument):

    def __init__(self, help='', parsed_name=None, default=None):

        super(FlagArgument, self).__init__(0, help, parsed_name, default)

class ValueArgument(Argument):

    def __init__(self, help='', parsed_name=None, default=None):

        super(ValueArgument, self).__init__(1, help, parsed_name, default)

class VersionArgument(FlagArgument):

    @property 

    def value(self):

        return super(self.__class__, self).value

    @value.setter

    def value(self, newvalue):

        self._value = newvalue

        self.main()

    def main(self):

        if self.value:

            import kamaki

            print('kamaki %s'%kamaki.__version__)

    debug = FlagArgument('Include debug output', ('-d', '--debug')),

    include = FlagArgument('Include protocol headers in the output', ('-i', '--include')),

    silent = FlagArgument('Do not output anything', ('-s', '--silent')),

    verbose = FlagArgument('More info at response', ('-v', '--verbose')),

    version = VersionArgument('Print current version', ('-V', '--version')),

    options = CmdLineConfigArgument(_config_arg, 'Override a config value', ('-o', '--options'))

    parsed, unparsed = parser.parse_known_args()

    for name, arg in _arguments.items():

        arg.value = getattr(parsed, name, arg.value)

    return parsed, unparsed