Mercurial Repository: p/roundup/code: roundup/admin.py comparison

comparison roundup/admin.py @ 2307:f786a1b9dbdf

translatabe strings adjustments, postponed help text translation

author	Alexander Smishlajev <a1s@users.sourceforge.net>
date	Fri, 14 May 2004 20:01:16 +0000
parents	19d1cd9ab09b
children	8d5c95c33447

comparison

equal deleted inserted replaced

-:1421b19cd61b
+:f786a1b9dbdf
 # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
 # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 # FOR A PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
 # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 #
-# $Id: admin.py,v 1.68 2004-04-17 01:47:37 richard Exp $
+# $Id: admin.py,v 1.69 2004-05-14 20:01:16 a1s Exp $
 '''Administration commands for maintaining Roundup trackers.
 '''
 __docformat__ = 'restructuredtext'
 roundup-admin help all                   -- all available help
 ''')%locals()
 self.help_commands()
 def help_commands(self):
-''' List the commands available with their precis help.
+''' List the commands available with their precise help.
 '''
 print _('Commands:'),
 commands = ['']
 for command in self.commands.values():
-h = command.__doc__.split('\n')[0]
+h = _(command.__doc__).split('\n')[0]
 commands.append(' '+h[7:])
 commands.sort()
-commands.append(_('Commands may be abbreviated as long as the abbreviation matches only one'))
+commands.append(_(
-commands.append(_('command, e.g. l == li == lis == list.'))
+"""Commands may be abbreviated as long as the abbreviation
+matches only one command, e.g. l == li == lis == list."""))
 print '\n'.join(commands)
 print
 def help_commands_html(self, indent_re=re.compile(r'^(\s+)\S+')):
 ''' Produce an HTML command list.
 commands = self.commands.values()
 def sortfun(a, b):
 return cmp(a.__name__, b.__name__)
 commands.sort(sortfun)
 for command in commands:
-h = command.__doc__.split('\n')
+h = _(command.__doc__).split('\n')
 name = command.__name__[3:]
 usage = h[0]
 print _('''
 <tr><td valign=top><strong>%(name)s</strong></td>
 <td><tt>%(usage)s</tt><p>
 print _('</pre></td></tr>\n')
 def help_all(self):
 print _('''
 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 where
 roundup keeps the database and configuration file that defines an issue
 tracker. It may be thought of as the issue tracker's "home directory". It may
 be specified in the environment variable TRACKER_HOME or on the command
 line as "-i tracker".
 \\               (1 token: \)
 \n\r\t           (1 token: a newline, carriage-return and tab)
 When multiple nodes are specified to the roundup get or roundup set
 commands, the specified properties are retrieved or set on all the listed
 nodes.
 When multiple results are returned by the roundup get or roundup find
 commands, they are printed one per line (default) or joined by commas (with
 the -c) option.
 Where the command changes data, a login name/password is required. The
 login may be specified as either "name" or "name:password".
 . ROUNDUP_LOGIN environment variable
 . the -u command-line option
 If either the name or password is not supplied, they are obtained from the
 command-line.
 Date format examples:
 "2000-04-17.03:45" means <Date 2000-04-17.08:45:00>
 "2000-04-17" means <Date 2000-04-17.00:00:00>
 "01-25" means <Date yyyy-01-25.00:00:00>
 Command help:
 ''')
 for name, command in self.commands.items():
 print _('%s:')%name
-print _('   '), command.__doc__
+print _('   '), _(command.__doc__)
 def do_help(self, args, nl_re=re.compile('[\r\n]'),
 indent_re=re.compile(r'^(\s+)\S+')):
-'''Usage: help topic
+""'''Usage: help topic
 Give help about topic.
 commands  -- list commands
 <command> -- help specific to a command
 initopts  -- init command options
 '''
 if len(args)>0:
 topic = args[0]
 else:
 topic = 'help'
 # try help_ methods
 if self.help.has_key(topic):
 self.help[topic]()
 return 0
 print _('Sorry, no help for "%(topic)s"')%locals()
 return 1
 # display the help for each match, removing the docsring indent
 for name, help in l:
-lines = nl_re.split(help.__doc__)
+lines = nl_re.split(_(help.__doc__))
 print lines[0]
 indent = indent_re.match(lines[1])
 if indent: indent = len(indent.group(1))
 for line in lines[1:]:
 if indent:
 import roundup.backends
 backends = roundup.backends.__all__
 print _('Back ends:'), ', '.join(backends)
 def do_install(self, tracker_home, args):
-'''Usage: install [template [backend [admin password]]]
+""'''Usage: install [template [backend [admin password]]]
 Install a new Roundup tracker.
 The command will prompt for the tracker home directory (if not supplied
 through TRACKER_HOME or the -i option). The template, backend and admin
 password may be specified on the command-line as arguments, in that
 if not os.path.exists(parent):
 raise UsageError, _('Instance home parent directory "%(parent)s"'
 ' does not exist')%locals()
 if os.path.exists(os.path.join(tracker_home, 'config.py')):
-print _('WARNING: There appears to be a tracker in '
+ok = raw_input(_(
-'"%(tracker_home)s"!')%locals()
+"""WARNING: There appears to be a tracker in "%(tracker_home)s"!
-print _('If you re-install it, you will lose all the data!')
+If you re-install it, you will lose all the data!
-ok = raw_input(_('Erase it? Y/N: ')).strip()
+Erase it? Y/N: """) % locals())
 if ok.strip().lower() != 'y':
 return 0
 # clear it out so the install isn't confused
 shutil.rmtree(tracker_home)
 }
 return 0
 def do_initialise(self, tracker_home, args):
-'''Usage: initialise [adminpw]
+""'''Usage: initialise [adminpw]
 Initialise a new Roundup tracker.
 The administrator details will be set at this step.
 Execute the tracker's initialisation function dbinit.init()
 db_exists = tracker.select_db.Database.exists(tracker.config)
 except AttributeError:
 # TODO: move this code to exists() static method in every backend
 db_exists = os.path.exists(os.path.join(tracker_home, 'db'))
 if db_exists:
-print _('WARNING: The database is already initialised!')
+ok = raw_input(_(
-print _('If you re-initialise it, you will lose all the data!')
+"""WARNING: The database is already initialised!
-ok = raw_input(_('Erase it? Y/N: ')).strip()
+If you re-initialise it, you will lose all the data!
+Erase it? Y/N: """))
 if ok.strip().lower() != 'y':
 return 0
 # Get a database backend in use by tracker
 try:
 return 0
 def do_get(self, args):
-'''Usage: get property designator[,designator]*
+""'''Usage: get property designator[,designator]*
 Get the given property of one or more designator(s).
 Retrieves the property value of the nodes specified by the designators.
 '''
 if len(args) < 2:
 return 0
 def do_set(self, args, pwre = re.compile(r'{(\w+)}(.+)')):
-'''Usage: set items property=value property=value ...
+""'''Usage: set items property=value property=value ...
 Set the given properties of one or more items(s).
 The items are specified as a class or as a comma-separated
 list of item designators (ie "designator[,designator,...]").
 import traceback; traceback.print_exc()
 raise UsageError, message
 return 0
 def do_find(self, args):
-'''Usage: find classname propname=value ...
+""'''Usage: find classname propname=value ...
 Find the nodes of the given class with a given link property value.
 Find the nodes of the given class with a given link property value. The
 value may be either the nodeid of the linked node, or its key value.
 '''
 # get the linked-to class and look up the key property
 link_class = self.db.getclass(property.classname)
 try:
 props[propname] = link_class.lookup(value)
 except TypeError:
-raise UsageError, _('%(classname)s has no key property"')%{
+raise UsageError, _('%(classname)s has no key property')%{
 'classname': link_class.classname}
 # now do the find
 try:
 id = []
 designator = []
 if self.separator:
 if self.print_designator:
 except (ValueError, TypeError), message:
 raise UsageError, message
 return 0
 def do_specification(self, args):
-'''Usage: specification classname
+""'''Usage: specification classname
 Show the properties for a classname.
 This lists the properties for a given class.
 '''
 if len(args) < 1:
 print _('%(key)s: %(value)s (key property)')%locals()
 else:
 print _('%(key)s: %(value)s')%locals()
 def do_display(self, args):
-'''Usage: display designator[,designator]*
+""'''Usage: display designator[,designator]*
 Show the property values for the given node(s).
 This lists the properties and their associated values for the given
 node.
 '''
 for key in keys:
 value = cl.get(nodeid, key)
 print _('%(key)s: %(value)s')%locals()
 def do_create(self, args, pwre = re.compile(r'{(\w+)}(.+)')):
-'''Usage: create classname property=value ...
+""'''Usage: create classname property=value ...
 Create a new entry of a given class.
 This creates a new entry of the given class using the property
 name=value arguments provided on the command line after the "create"
 command.
 except (TypeError, IndexError, ValueError), message:
 raise UsageError, message
 return 0
 def do_list(self, args):
-'''Usage: list classname [property]
+""'''Usage: list classname [property]
 List the instances of a class.
 Lists all instances of the given class. If the property is not
 specified, the  "label" property is used. The label property is tried
 in order: the key, "name", "title" and then the first property,
 '"%(propname)s"')%locals()
 print _('%(nodeid)4s: %(value)s')%locals()
 return 0
 def do_table(self, args):
-'''Usage: table classname [property[,property]*]
+""'''Usage: table classname [property[,property]*]
 List the instances of a class in tabular form.
 Lists all instances of the given class. If the properties are not
 specified, all properties are displayed. By default, the column widths
 are the width of the largest value. The width may be explicitly defined
 by defining the property as "name:width". For example::
 roundup> table priority id,name:10
 Id Name
 1  fatal-bug
 2  bug
 3  usability
 4  feature
 Also to make the width of the column the width of the label,
 leave a trailing : without a width on the property. For example::
 roundup> table priority id,name:
 Id Name
 1  fata
 2  bug
 3  usab
 4  feat
 will result in a the 4 character wide "Name" column.
 '''
 for nodeid in cl.list():
 curlen = len(str(cl.get(nodeid, spec)))
 if curlen > maxlen:
 maxlen = curlen
 props.append((spec, maxlen))
 # now display the heading
 print ' '.join([name.capitalize().ljust(width) for name,width in props])
 # and the table data
 for nodeid in cl.list():
 l.append(f%value[:width])
 print ' '.join(l)
 return 0
 def do_history(self, args):
-'''Usage: history designator
+""'''Usage: history designator
 Show the history entries of a designator.
 Lists the journal entries for the node identified by the designator.
 '''
 if len(args) < 1:
 except IndexError:
 raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
 return 0
 def do_commit(self, args):
-'''Usage: commit
+""'''Usage: commit
 Commit changes made to the database during an interactive session.
 The changes made during an interactive session are not
 automatically written to the database - they must be committed
 using this command.
 '''
 self.db.commit()
 return 0
 def do_rollback(self, args):
-'''Usage: rollback
+""'''Usage: rollback
 Undo all changes that are pending commit to the database.
 The changes made during an interactive session are not
 automatically written to the database - they must be committed
 manually. This command undoes all those changes, so a commit
 '''
 self.db.rollback()
 return 0
 def do_retire(self, args):
-'''Usage: retire designator[,designator]*
+""'''Usage: retire designator[,designator]*
 Retire the node specified by designator.
 This action indicates that a particular node is not to be retrieved by
 the list or find commands, and its key value may be re-used.
 '''
 except IndexError:
 raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
 return 0
 def do_restore(self, args):
-'''Usage: restore designator[,designator]*
+""'''Usage: restore designator[,designator]*
 Restore the retired node specified by designator.
 The given nodes will become available for users again.
 '''
 if len(args) < 1:
 except IndexError:
 raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
 return 0
 def do_export(self, args):
-'''Usage: export [class[,class]] export_dir
+""'''Usage: export [class[,class]] export_dir
 Export the database to colon-separated-value files.
 Optionally limit the export to just the names classes.
 This action exports the current data from the database into
 map(journals.writerow, cl.export_journals())
 jf.close()
 return 0
 def do_import(self, args):
-'''Usage: import import_dir
+""'''Usage: import import_dir
 Import a database from the directory containing CSV files, two per
 class to import.
 The files used in the import are:
 self.db.setid(classname, str(maxid+1))
 return 0
 def do_pack(self, args):
-'''Usage: pack period | date
+""'''Usage: pack period | date
 Remove journal entries older than a period of time specified or
 before a certain date.
 A period is specified using the suffixes "y", "m", and "d". The
 suffix "w" (for "week") means 7 days.
 "3y" means three years
 "2y 1m" means two years and one month
 "1m 25d" means one month and 25 days
 "2w 3d" means two weeks and three days
 Date format is "YYYY-MM-DD" eg:
 2001-01-01
 '''
 if len(args) <> 1:
 raise UsageError, _('Not enough arguments supplied')
 # are we dealing with a period or a date
 value = args[0]
 date_re = re.compile(r'''
 (?P<date>\d\d\d\d-\d\d?-\d\d?)? # yyyy-mm-dd
 (?P<period>(\d+y\s*)?(\d+m\s*)?(\d+d\s*)?)?
 pack_before = date.Date(value)
 self.db.pack(pack_before)
 return 0
 def do_reindex(self, args):
-'''Usage: reindex
+""'''Usage: reindex
 Re-generate a tracker's search indexes.
 This will re-generate the search indexes for a tracker. This will
 typically happen automatically.
 '''
 self.db.indexer.force_reindex()
 self.db.reindex()
 return 0
 def do_security(self, args):
-'''Usage: security [Role name]
+""'''Usage: security [Role name]
 Display the Permissions available to one or all Roles.
 '''
 if len(args) == 1:
 role = args[0]
 try:
 return ret
 def interactive(self):
 '''Run in an interactive mode
 '''
-print _('Roundup %s ready for input.'%roundup_version)
+print _('Roundup %s ready for input.\nType "help" for help.'
-print _('Type "help" for help.')
+% roundup_version)
 try:
 import readline
 except ImportError:
 print _('Note: command history and editing not available')

Mercurial > p > roundup > code

comparison roundup/admin.py @ 2307:f786a1b9dbdf