add pragma command to roundup-admin

rouilj · rouilj · commit 5f2ea137f965 · 2023-04-12T20:49:21.000-04:00
Added basic pragma command. Can assign settings, list settings.
Most settings are not yet implemented.

Only the pragma command respects unhidden pragma settings at this
point.  Also added tests, doc updates for roundup-admin.

CHANGES.txt not updated because currently only pragma references the
unhidden settings.

Also fixed a couple of long lines.
diff --git a/doc/user_guide.txt b/doc/user_guide.txt
@@ -456,7 +456,7 @@ registration confirmation.
 If the subject line contains a prefix in ``[square brackets]`` then
 we're looking at case 3 or 4 above. Spaces are allowed inside the
 brackets and after the class item name. So ``[issue2]`` and
-``[ issue 2 ]`` are treted the same where any whitespace is optional.
+``[ issue 2 ]`` are treated the same where any white space is optional.
 Any "re:" or "fwd:" prefixes are stripped off the subject line before
 we start looking for real information.
 
@@ -767,6 +767,8 @@ The basic usage is::
   -S <string>       -- when outputting lists of data, string-separate them
   -s                -- when outputting lists of data, space-separate them.
                Same as '-S " "'.
+  -V                -- be verbose when importing
+  -v                -- report Roundup and Python versions (and quit)
 
   Only one of -s, -c or -S can be specified.
 
@@ -780,26 +782,35 @@ The basic usage is::
   commit
   create classname property=value ...
   display designator[,designator]*
-  export [class[,class]] export_dir
+  export [[-]class[,class]] export_dir
+  exporttables [[-]class[,class]] export_dir
+  filter classname propname=value ...
   find classname propname=value ...
+  genconfig <filename>
   get property designator[,designator]*
   help topic
-  history designator
+  history designator [skipquiet]
   import import_dir
+  importtables export_dir
   initialise [adminpw]
-  install [template [backend [admin password]]]
+  install [template [backend [key=val[,key=val]]]]
   list classname [property]
+  migrate
   pack period | date
-  reindex
+  perftest [mode] [arguments]*
+  pragma setting=value
+  reindex [classname|designator]*
+  restore designator[,designator]*
   retire designator[,designator]*
   rollback
   security [Role name]
   set items property=value property=value ...
   specification classname
   table classname [property[,property]*]
- Commands may be abbreviated as long as the abbreviation matches only one
- command, e.g. l == li == lis == list.
-
+  templates [trace_search]
+  updateconfig <filename>
+ Commands may be abbreviated as long as the abbreviation
+ matches only one command, e.g. l == li == lis == list.
 
 All commands (except help) require a tracker specifier. This is just the
 path to the roundup tracker you're working with. A roundup tracker is
diff --git a/roundup/admin.py b/roundup/admin.py
@@ -102,6 +102,31 @@ def __init__(self):
         self.db = None
         self.db_uncommitted = False
         self.force = None
+        self.settings = {
+            'display_protected': False,
+            'indexer_backend': "as set in config.ini",
+            '_reopen_tracker': False,
+            'show_retired': False,
+            'verbose': False,
+            '_inttest': 3,
+            '_floattest': 3.5,
+        }
+        self.settings_help = {
+            'display_protected':
+            _("Have 'display designator' show protected fields: creator. NYI"),
+
+            'indexer_backend': 
+            _("Set indexer to use when running 'reindex' NYI"),
+
+            '_reopen_tracker':
+            _("Force reopening of tracker when running each command."),
+
+            'show_retired': _("Show retired items in table, list etc. NYI"),
+            'verbose': _("Enable verbose output: tracing, descriptions..."),
+
+            '_inttest': "Integer valued setting. For testing only.",
+            '_floattest': "Float valued setting. For testing only.",
+        }
 
     def get_class(self, classname):
         """Get the class - raise an exception if it doesn't exist.
@@ -440,8 +465,9 @@ def do_create(self, args):
                     if value:
                         props[key] = value
                 else:
-                    value = self.my_input(_('%(propname)s (%(proptype)s): ') % {
-                        'propname': key.capitalize(), 'proptype': name})
+                    value = self.my_input(_(
+                        '%(propname)s (%(proptype)s): ') % {
+                            'propname': key.capitalize(), 'proptype': name})
                     if value:
                         props[key] = value
         else:
@@ -797,8 +823,7 @@ def do_genconfig(self, args, update=False):
                             "old_number":
                             config.PASSWORD_PBKDF2_DEFAULT_ROUNDS,
                             "new_number": default_ppdr
-                        }
-                )
+                        })
                 config.PASSWORD_PBKDF2_DEFAULT_ROUNDS = default_ppdr
 
             if config.PASSWORD_PBKDF2_DEFAULT_ROUNDS < default_ppdr:
@@ -1435,6 +1460,75 @@ def do_perftest(self, args):
                   {"time": toc-tic, "scheme": props['scheme'],
                    "rounds": rounds})
 
+    def do_pragma(self, args):
+        ''"""Usage: pragma setting=value | 'list'
+        Set internal admin settings to a value. E.G.
+
+            pragma verbose=True
+            pragma verbose=yes
+            pragma verbose=on
+            pragma verbose=1
+
+         will turn on verbose mode for roundup-admin.
+
+            pragma list
+
+         will show all settings and their current values. If verbose
+         is enabled hidden settings and descriptions will be shown.
+        """
+
+        if len(args) < 1:
+            raise UsageError(_('Not enough arguments supplied'))
+
+        try:
+            (setting, value) = args[0].split("=", 1)
+        except ValueError:
+            if args[0] != "list":
+                raise UsageError(_(
+                    'Argument must be setting=value, was given: %s.') %
+                                 args[0])
+            else:
+                print(_("Current settings and values "
+                        "(NYI - not yet implemented):"))
+                is_verbose = self.settings['verbose']
+                for key in sorted(list(self.settings.keys())):
+                    if key.startswith('_') and not is_verbose:
+                        continue
+                    print("   %s=%s" % (key, self.settings[key]))
+                    if is_verbose:
+                        print("      %s" % self.settings_help[key])
+
+                return
+
+        if setting not in self.settings:
+            raise UsageError(_('Unknown setting %s.') % setting)
+        if type(self.settings[setting]) is bool:
+            value = value.lower()
+            if value in ("yes", "true", "on", "1"):
+                value = True
+            elif value in ("no", "false", "off", "0"):
+                value = False
+            else:
+                raise UsageError(_(
+                    'Incorrect value for boolean setting %(setting)s: '
+                    '%(value)s.') % {"setting": setting, "value": value})
+        elif type(self.settings[setting]) is int:
+            try:
+                _val = int(value)
+            except ValueError:
+                raise UsageError(_(
+                    'Incorrect value for integer setting %(setting)s: '
+                    '%(value)s.') % {"setting": setting, "value": value})
+            value = _val
+        elif type(self.settings[setting]) is str:
+            pass
+        else:
+            raise UsageError(_('Internal error: pragma can not handle '
+                               'values of type: %s') %
+                             type(self.settings[setting]).__name__)
+
+        self.settings[setting] = value
+
     designator_re = re.compile('([A-Za-z]+)([0-9]+)')
 
     def do_reindex(self, args, desre=designator_re):
diff --git a/share/man/man1/roundup-admin.1 b/share/man/man1/roundup-admin.1
@@ -205,6 +205,21 @@ before a certain date.
 Run performance test. For example test the effect
 of changing password hashing parameters.
 .TP
+\fBpragma\fP \fIsetting=value\fP|\fBlist\fP
+Set internal settings to a value. E.G.
+
+     pragma verbose=True
+     pragma verbose=yes
+     pragma verbose=on
+     pragma verbose=1
+
+will turn on verbose mode for roundup-admin.
+
+     pragma list
+
+will show all settings and their current values. If verbose
+is enabled hidden settings and descriptions will be shown.
+.TP
 \fBreindex\fP \fI[classname|designator]*\fP
 This will re-generate the search indexes for a tracker.
 .TP
diff --git a/test/test_admin.py b/test/test_admin.py
@@ -803,6 +803,173 @@ def testFilter(self):
         print(err.getvalue().strip())
         self.assertEqual(out, "issue1:issue2")
 
+    def testPragma(self):
+        """Uses interactive mode since pragmas only apply when using multiple
+           commands.
+        """
+        if self.backend not in ['anydbm']:
+            self.skipTest("For speed only run test with anydbm.")
+
+        orig_input = AdminTool.my_input
+
+        for i in ["oN", "1", "yeS", "True"]:
+            inputs = iter(["pragma verbose=%s" % i, "pragma list", "quit"])
+            AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+            self.install_init()
+            self.admin=AdminTool()
+            sys.argv=['main', '-i', self.dirname]
+
+            with captured_output() as (out, err):
+                ret = self.admin.main()
+
+            out = out.getvalue().strip().split('\n')
+        
+            print(ret)
+            self.assertTrue(ret == 0)
+            expected = '   verbose=True'
+            self.assertIn(expected, out)
+            self.assertIn('descriptions...', out[-1])
+
+        # -----
+        for i in ["oFf", "0", "NO", "FalSe"]:
+            inputs = iter(["pragma verbose=true", "pragma verbose=%s" % i,
+                           "pragma list", "quit"])
+            AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+            self.install_init()
+            self.admin=AdminTool()
+            sys.argv=['main', '-i', self.dirname]
+
+            with captured_output() as (out, err):
+                ret = self.admin.main()
+
+            out = out.getvalue().strip().split('\n')
+        
+            print(ret)
+            self.assertTrue(ret == 0)
+            expected = '   verbose=False'
+            self.assertIn(expected, out)
+
+        # -----  test syntax errors
+        inputs = iter(["pragma", "pragma arg",
+                       "pragma foo=3","quit"])
+        AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+        self.install_init()
+        self.admin=AdminTool()
+        sys.argv=['main', '-i', self.dirname]
+
+        with captured_output() as (out, err):
+            ret = self.admin.main()
+
+        out = out.getvalue().strip().split('\n')
+        
+        print(ret)
+        self.assertTrue(ret == 0)
+        expected = 'Error: Not enough arguments supplied'
+        self.assertIn(expected, out)
+        expected = 'Error: Argument must be setting=value, was given: arg.'
+        self.assertIn(expected, out)
+        expected = 'Error: Unknown setting foo.'
+        self.assertIn(expected, out)
+
+        # -----
+        inputs = iter(["pragma verbose=foo", "quit"])
+        AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+        self.install_init()
+        self.admin=AdminTool()
+        sys.argv=['main', '-i', self.dirname]
+
+        with captured_output() as (out, err):
+            ret = self.admin.main()
+
+        out = out.getvalue().strip().split('\n')
+        
+        print(ret)
+        self.assertTrue(ret == 0)
+        expected = 'Error: Incorrect value for boolean setting verbose: foo.'
+        self.assertIn(expected, out)
+
+        # -----
+        inputs = iter(["pragma verbose=on", "pragma _inttest=5",
+                       "pragma list", "quit"])
+        AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+        self.install_init()
+        self.admin=AdminTool()
+        sys.argv=['main', '-i', self.dirname]
+
+        with captured_output() as (out, err):
+            ret = self.admin.main()
+
+        out = out.getvalue().strip().split('\n')
+        
+        print(ret)
+        self.assertTrue(ret == 0)
+        expected = '   _inttest=5'
+        self.assertIn(expected, out)
+        self.assertIn('descriptions...', out[-1])
+
+
+        # -----
+        inputs = iter(["pragma verbose=on", "pragma _inttest=fred",
+                       "pragma list", "quit"])
+        AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+        self.install_init()
+        self.admin=AdminTool()
+        sys.argv=['main', '-i', self.dirname]
+
+        with captured_output() as (out, err):
+            ret = self.admin.main()
+
+        out = out.getvalue().strip().split('\n')
+        
+        print(ret)
+        self.assertTrue(ret == 0)
+        expected = 'Error: Incorrect value for integer setting _inttest: fred.'
+        self.assertIn(expected, out)
+        self.assertIn('descriptions...', out[-1])
+
+        # -----
+        inputs = iter(["pragma indexer_backend=whoosh", "pragma list",
+                       "quit"])
+        AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+        self.install_init()
+        self.admin=AdminTool()
+        sys.argv=['main', '-i', self.dirname]
+
+        with captured_output() as (out, err):
+            ret = self.admin.main()
+
+        out = out.getvalue().strip().split('\n')
+        
+        print(ret)
+        expected = '   indexer_backend=whoosh'
+        self.assertIn(expected, out)
+
+        # -----
+        inputs = iter(["pragma _floattest=4.5", "quit"])
+        AdminTool.my_input = lambda _self, _prompt: next(inputs)
+
+        self.install_init()
+        self.admin=AdminTool()
+        sys.argv=['main', '-i', self.dirname]
+
+        with captured_output() as (out, err):
+            ret = self.admin.main()
+
+        out = out.getvalue().strip().split('\n')
+        
+        print(ret)
+        expected = 'Error: Internal error: pragma can not handle values of type: float'
+        self.assertIn(expected, out)
+
+        # -----
+        AdminTool.my_input = orig_input
 
     def disabletestHelpInitopts(self):
 
