Enable support for passing global options

Author: jirikuncar

flask_script/__init__.py

@@ -123,29 +123,39 @@ def create_app(self, **kwargs):
 
         return self.app(**kwargs)
 
-    def create_parser(self, prog, parser=None):
+    def create_parser(self, prog, parents=None):
 
         """
         Creates an ArgumentParser instance from options returned
         by get_options(), and a subparser for the given command.
         """
         prog = os.path.basename(prog)
 
-        if parser is None:
-            parser = argparse.ArgumentParser(prog=prog, usage=self.usage)
-
-        #parser.set_defaults(func_handle=self._handle)
-
+        option_parser = argparse.ArgumentParser(add_help=False)
         for option in self.get_options():
-            parser.add_argument(*option.args, **option.kwargs)
+            option_parser.add_argument(*option.args, **option.kwargs)
+
+        if parents is None:
+            parents = [option_parser]
 
-        subparsers = parser.add_subparsers()  # dest='subparser_'+prog)
-        for name, command in self._commands.iteritems():
+        def _create_command(item):
+            name, command = item
             description = getattr(command, 'description',
-                                  'Perform command ' + name)
-            p = subparsers.add_parser(name, help=description, usage=description)
-            p = command.create_parser(name, parser=p)
+                                  command.__doc__)
+            return name, command, description, \
+                command.create_parser(name, parents=parents)
 
+        commands = map(_create_command, self._commands.iteritems())
+
+        parser = argparse.ArgumentParser(prog=prog, usage=self.usage,
+                                         parents=parents)
+
+        #parser.set_defaults(func_handle=self._handle)
+
+        subparsers = parser.add_subparsers()
+        for name, command, description, parent in commands:
+            subparsers.add_parser(name, usage=description, help=description,
+                                  parents=[parent], add_help=False)
         return parser
 
     def get_options(self):
@@ -315,11 +325,16 @@ def _handle(self, app, *args, **kwargs):
 
     def handle(self, prog, args=None):
 
-        args = list(args or [])
-
         app_parser = self.create_parser(prog)
+
+        if args is None or len(args) == 0:
+            app_parser.print_help()
+            return 2
+
+        args = list(args or [])
         app_namespace, remaining_args = app_parser.parse_known_args(args)
 
+        ## get the handle function and remove it from parsed options
         kwargs = app_namespace.__dict__
         handle = kwargs['func_handle']
         del kwargs['func_handle']

flask_script/commands.py

@@ -113,22 +113,22 @@ def get_options(self):
         """
         return self.option_list
 
-    def create_parser(self, prog, parser=None):
-        if parser is None:
-            parser = argparse.ArgumentParser(prog=prog,
-                                             description=self.description)
+    def create_parser(self, prog, parents=None):
+
+        parser = argparse.ArgumentParser(prog=prog, parents=parents,
+                                         description=self.description)
 
         for option in self.get_options():
             if isinstance(option, Group):
                 if option.exclusive:
                     group = parser.add_mutually_exclusive_group(
-                                required=option.required,
-                            )
+                        required=option.required,
+                    )
                 else:
                     group = parser.add_argument_group(
-                                title=option.title,
-                                description=option.description,
-                            )
+                        title=option.title,
+                        description=option.description,
+                    )
                 for opt in option.get_options():
                     group.add_argument(*opt.args, **opt.kwargs)
             else:

tests.py

@@ -25,6 +25,9 @@ def run(command_line, manager_run, capture_stderr=False):
         exit_code = e.code
     finally:
         out = sys.stdout.getvalue()
+        # clear the standard output buffer
+        sys.stdout.truncate(0)
+        assert len(sys.stdout.getvalue()) == 0
         if capture_stderr:
             out += sys.stderr.getvalue()
         sys.stderr = sys_stderr_orig
@@ -260,7 +263,7 @@ def hello_again(name, url=None):
         stdout, code = run('manage.py hello_again --name=joe --url=reddit.com', lambda: manager.run())
         assert 'hello joe from reddit.com' in stdout
 
-    def test_global_option_provided_before_command(self):
+    def test_global_option_provided_before_and_after_command(self):
 
         manager = Manager(self.app)
         manager.add_option('-c', '--config', dest='config_name', required=False, default='Development')
@@ -272,6 +275,44 @@ def test_global_option_provided_before_command(self):
         assert code == 0
         assert 'OK' in stdout
 
+        stdout, code = run('manage.py simple -c Development', lambda: manager.run())
+        assert code == 0
+        assert 'OK' in stdout
+
+    def test_global_option_value(self):
+
+        def create_app(config_name='Empty'):
+            print config_name
+            return self.app
+
+        manager = Manager(create_app)
+        manager.add_option('-c', '--config', dest='config_name', required=False, default='Development')
+        manager.add_command('simple', SimpleCommand())
+
+        assert isinstance(manager._commands['simple'], SimpleCommand)
+
+        stdout, code = run('manage.py simple', lambda: manager.run())
+        assert code == 0
+        assert 'Empty' not in stdout  # config_name is overwritten by default option value
+        assert 'Development' in stdout
+        assert 'OK' in stdout
+
+        stdout, code = run('manage.py -c Before simple', lambda: manager.run())
+        assert code == 0
+        assert 'Before' in stdout
+        assert 'OK' in stdout
+
+        stdout, code = run('manage.py simple -c After', lambda: manager.run())
+        assert code == 0
+        assert 'After' in stdout
+        assert 'OK' in stdout
+
+        stdout, code = run('manage.py -c DoNotShow simple -c NewValue', lambda: manager.run())
+        assert code == 0
+        assert 'DoNotShow' not in stdout  # first parameter is ignored
+        assert 'NewValue' in stdout       # second on is printed
+        assert 'OK' in stdout
+
     def test_get_usage(self):
 
         manager = Manager(self.app)