This effectively *is* the ``rattail`` console application.  It mostly

    provides the structure for subcommands, which really do all the work.

    This command is designed to be subclassed, should your application need

    similar functionality.

    """

    name = 'rattail'

    version = __version__

    description = "Retail Software Framework"

    long_description = """

Rattail is a retail software framework.

This program comes with ABSOLUTELY NO WARRANTY.  This is free software,

and you are welcome to redistribute it under certain conditions.

See the file COPYING.txt for more information.

"""

    stdout = sys.stdout

    stderr = sys.stderr

    def __init__(self):

        self.subcommands = load_entry_points('{0}.commands'.format(self.name))

    def run(self, *args):

        """

        Parse command line arguments and execute appropriate subcommand.

        """

        parser = ArgumentParser(

            prog=self.name,

            description=self.description,

            add_help=False,

            )

        parser.add_argument('-c', '--config', action='append', dest='config_paths',

                            metavar='PATH')

        parser.add_argument('-n', '--no-init', action='store_true', default=False)

        parser.add_argument('-P', '--progress', action='store_true', default=False)

        parser.add_argument('--stdout', metavar='PATH', type=argparse.FileType('w'),

                            help="Optional path to which STDOUT should be effectively redirected.")

        parser.add_argument('--stderr', metavar='PATH', type=argparse.FileType('w'),

                            help="Optional path to which STDERR should be effectively redirected.")

        parser.add_argument('-V', '--version', action='version',

                            version="%(prog)s {0}".format(self.version))

        parser.add_argument('command', nargs='*')

        # Parse args and determine subcommand.

        args = parser.parse_args(list(args))

        if not args or not args.command:

            self.print_help()

            return

        # Show (sub)command help if so instructed, or unknown subcommand.

        cmd = args.command.pop(0)

        if args.stderr:

            self.stderr = args.stderr

        # Basic logging should be established before init()ing.

        # Use root logger if setting logging flags.

        log = logging.getLogger()

        # TODO: Figure out the basic logging pattern we're after here.

        # edbob.basic_logging()

        logging.basicConfig()

        # Initialize everything...

        config = None

        if not args.no_init:

            edbob.init(self.name, *(args.config_paths or []))

            config = RattailConfig(edbob.config)

            # Configure the default database engine.

            try:

                from rattail.db.util import configure_session_factory

            except ImportError:

                pass            # assume no sqlalchemy

            else:

                configure_session_factory(config, section=self.db_config_section,

                                          session_factory=self.db_session_factory)

                # Maybe configure Continuum versioning.

                if (self.db_config_section == 'rattail.db'

                    and config.getboolean('rattail.db', 'versioning.enabled')):

            def run(self, args):

                self.stderr.write("standard error stuff")

                self.stderr.flush()

        command = commands.Command()

        fake = command.subcommands['fake'] = Fake

        tmp = TempIO()

        config_path = tmp.putfile('test.ini', '')

        err_path = tmp.putfile('err.txt', '')

        command.run('fake', '--config', config_path, '--stderr', err_path)

        with open(err_path) as f:

            self.assertEqual(f.read(), "standard error stuff")

    def test_noinit_flag_means_no_config(self):

        command = commands.Command()

        fake = command.subcommands['fake'] = Mock()

        command.run('fake', '--no-init')

        self.assertTrue(fake.return_value.config is None)

class TestSubcommand(TestCase):

    def test_repr(self):

        command = commands.Command()

        subcommand = commands.Subcommand(command)