Mercurial Repository: p/roundup/code: doc/design.txt comparison

comparison doc/design.txt @ 1711:3c3e44aacdb4

Documentation fixes. doc/customizing.txt, doc/design.txt Documented 'db.curuserid'. doc/design.txt Reflowed to 72 columns (even the layer cake fits :) roundup/mailgw.py Strip '\n' introduced by rfc822.readheaders

author	Jean Jordaan <neaj@users.sourceforge.net>
date	Tue, 24 Jun 2003 12:39:20 +0000
parents	eb3c348676ed
children	84c61e912079

comparison

equal deleted inserted replaced

-:9595eee0c116
+:3c3e44aacdb4
 Lots of software design documents come with a picture of a cake.
 Everybody seems to like them.  I also like cakes (i think they are
 tasty).  So I, too, shall include a picture of a cake here::
-_________________________________________________________________________
+________________________________________________________________
-|  E-mail Client   |   Web Browser   |   Detector Scripts   |    Shell    |
+| E-mail Client |  Web Browser  |  Detector Scripts  |   Shell   |
-|------------------+-----------------+----------------------+-------------|
+|---------------+---------------+--------------------+-----------|
-|   E-mail User    |    Web User     |      Detector        |   Command   |
+|  E-mail User  |   Web User    |     Detector       |  Command  |
-|-------------------------------------------------------------------------|
+|----------------------------------------------------------------|
-|                         Roundup Database Layer                          |
+|                    Roundup Database Layer                      |
-|-------------------------------------------------------------------------|
+|----------------------------------------------------------------|
-|                          Hyperdatabase Layer                            |
+|                     Hyperdatabase Layer                        |
-|-------------------------------------------------------------------------|
+|----------------------------------------------------------------|
-|                             Storage Layer                               |
+|                        Storage Layer                           |
--------------------------------------------------------------------------
+----------------------------------------------------------------
 The colourful parts of the cake are part of our system; the faint grey
 parts of the cake are external components.
 I will now proceed to forgo all table manners and eat from the bottom of
 Here is an outline of the Date and Interval classes::
 class Date:
 def __init__(self, spec, offset):
-"""Construct a date given a specification and a time zone offset.
+"""Construct a date given a specification and a time zone
+offset.
 'spec' is a full date or a partial form, with an optional
 added or subtracted interval.  'offset' is the local time
 zone offset from GMT in hours.
 """
 def __add__(self, interval):
 """Add an interval to this date to produce another date."""
 def __sub__(self, interval):
-"""Subtract an interval from this date to produce another date."""
+"""Subtract an interval from this date to produce another
+date.
+"""
 def __cmp__(self, other):
 """Compare this date to another date."""
 def __str__(self):
-"""Return this date as a string in the yyyy-mm-dd.hh:mm:ss format."""
+"""Return this date as a string in the yyyy-mm-dd.hh:mm:ss
+format.
+"""
 def local(self, offset):
-"""Return this date as yyyy-mm-dd.hh:mm:ss in a local time zone."""
+"""Return this date as yyyy-mm-dd.hh:mm:ss in a local time
+zone.
+"""
 class Interval:
 def __init__(self, spec):
 """Construct an interval given a specification."""
 >>> Interval("  3w  1  d  2:00")
 <Interval 22d 2:00>
 >>> Date(". + 2d") - Interval("3w")
 <Date 2000-06-07.00:34:02>
 Items and Classes
 ~~~~~~~~~~~~~~~~~
 Items contain data in properties.  To Python, these properties are
 presented as the key-value pairs of a dictionary. Each item belongs to a
 class which defines the names and types of its properties.  The database
 permits the creation and modification of classes as well as items.
 Identifiers and Designators
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Each item has a numeric identifier which is unique among items in its
 identify an item in the database, and consists of the name of the item's
 class concatenated with the item's numeric identifier.
 For example, if "spam" and "eggs" are classes, the first item created in
 class "spam" has id 1 and designator "spam1". The first item created in
-class "eggs" also has id 1 but has the distinct designator "eggs1".
+class "eggs" also has id 1 but has the distinct designator "eggs1". Item
-Item designators are conventionally enclosed in square brackets when
+designators are conventionally enclosed in square brackets when
 mentioned in plain text.  This permits a casual mention of, say,
 "[patch37]" in an e-mail message to be turned into an active hyperlink.
 Property Names and Types
 ~~~~~~~~~~~~~~~~~~~~~~~~
 Property names must begin with a letter.
 *None* is also a permitted value for any of these property types.  An
 attempt to store None into a Multilink property stores an empty list.
 A property that is not specified will return as None from a *get*
 operation.
 Hyperdb Interface Specification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 TODO: replace the Interface Specifications with links to the pydoc
 Here is the interface provided by the hyperdatabase::
 class Database:
-"""A database for storing records containing flexible data types."""
+"""A database for storing records containing flexible data
+types.
+"""
 def __init__(self, config, journaltag=None):
 """Open a hyperdatabase given a specifier to some storage.
 The 'storagelocator' is obtained from config.DATABASE. The
 """Return a list of the names of all existing classes."""
 def getclass(self, classname):
 """Get the Class object representing a particular class.
-If 'classname' is not a valid class name, a KeyError is raised.
+If 'classname' is not a valid class name, a KeyError is
+raised.
 """
 class Class:
-"""The handle to a particular class of items in a hyperdatabase."""
+"""The handle to a particular class of items in a hyperdatabase.
+"""
 def __init__(self, db, classname, **properties):
-"""Create a new class with a given name and property specification.
+"""Create a new class with a given name and property
+specification.
-'classname' must not collide with the name of an existing class,
-or a ValueError is raised.  The keyword arguments in 'properties'
+'classname' must not collide with the name of an existing
-must map names to property objects, or a TypeError is raised.
+class, or a ValueError is raised.  The keyword arguments in
+'properties' must map names to property objects, or a
+TypeError is raised.
+A proxied reference to the database is available as the
+'db' attribute on instances. For example, in
+'IssueClass.send_message', the following is used to lookup
+users, messages and files::
+users = self.db.user
+messages = self.db.msg
+files = self.db.file
+The id of the current user is also available on the database
+as 'self.db.curuserid'.
 """
 # Editing items:
 def create(self, **propvalues):
 """Create a new item of this class and return its id.
-The keyword arguments in 'propvalues' map property names to values.
+The keyword arguments in 'propvalues' map property names to
-The values of arguments must be acceptable for the types of their
+values. The values of arguments must be acceptable for the
-corresponding properties or a TypeError is raised.  If this class
+types of their corresponding properties or a TypeError is
-has a key property, it must be present and its value must not
+raised.  If this class has a key property, it must be
-collide with other key strings or a ValueError is raised.  Any other
+present and its value must not collide with other key
-properties on this class that are missing from the 'propvalues'
+strings or a ValueError is raised.  Any other properties on
-dictionary are set to None.  If an id in a link or multilink
+this class that are missing from the 'propvalues' dictionary
-property does not refer to a valid item, an IndexError is raised.
+are set to None.  If an id in a link or multilink property
+does not refer to a valid item, an IndexError is raised.
 """
 def get(self, itemid, propname):
-"""Get the value of a property on an existing item of this class.
+"""Get the value of a property on an existing item of this
+class.
-'itemid' must be the id of an existing item of this class or an
-IndexError is raised.  'propname' must be the name of a property
+'itemid' must be the id of an existing item of this class or
-of this class or a KeyError is raised.
+an IndexError is raised.  'propname' must be the name of a
+property of this class or a KeyError is raised.
 """
 def set(self, itemid, **propvalues):
 """Modify a property on an existing item of this class.
-'itemid' must be the id of an existing item of this class or an
+'itemid' must be the id of an existing item of this class or
-IndexError is raised.  Each key in 'propvalues' must be the name
+an IndexError is raised.  Each key in 'propvalues' must be
-of a property of this class or a KeyError is raised.  All values
+the name of a property of this class or a KeyError is
-in 'propvalues' must be acceptable types for their corresponding
+raised.  All values in 'propvalues' must be acceptable types
-properties or a TypeError is raised.  If the value of the key
+for their corresponding properties or a TypeError is raised.
-property is set, it must not collide with other key strings or a
+If the value of the key property is set, it must not collide
-ValueError is raised.  If the value of a Link or Multilink
+with other key strings or a ValueError is raised.  If the
-property contains an invalid item id, a ValueError is raised.
+value of a Link or Multilink property contains an invalid
+item id, a ValueError is raised.
 """
 def retire(self, itemid):
 """Retire an item.
-The properties on the item remain available from the get() method,
+The properties on the item remain available from the get()
-and the item's id is never reused.  Retired items are not returned
+method, and the item's id is never reused.  Retired items
-by the find(), list(), or lookup() methods, and other items may
+are not returned by the find(), list(), or lookup() methods,
-reuse the values of their key properties.
+and other items may reuse the values of their key
+properties.
 """
 def restore(self, nodeid):
 '''Restore a retired node.
-Make node available for all operations like it was before retirement.
+Make node available for all operations like it was before
+retirement.
 '''
 def history(self, itemid):
 """Retrieve the journal of edits on a particular item.
-'itemid' must be the id of an existing item of this class or an
+'itemid' must be the id of an existing item of this class or
-IndexError is raised.
+an IndexError is raised.
 The returned list contains tuples of the form
 (date, tag, action, params)
-'date' is a Timestamp object specifying the time of the change and
+'date' is a Timestamp object specifying the time of the
-'tag' is the journaltag specified when the database was opened.
+change and 'tag' is the journaltag specified when the
-'action' may be:
+database was opened. 'action' may be:
-'create' or 'set' -- 'params' is a dictionary of property values
+'create' or 'set' -- 'params' is a dictionary of
-'link' or 'unlink' -- 'params' is (classname, itemid, propname)
+property values
+'link' or 'unlink' -- 'params' is (classname, itemid,
+propname)
 'retire' -- 'params' is None
 """
 # Locating items:
 def setkey(self, propname):
-"""Select a String property of this class to be the key property.
+"""Select a String property of this class to be the key
+property.
-'propname' must be the name of a String property of this class or
-None, or a TypeError is raised.  The values of the key property on
+'propname' must be the name of a String property of this
-all existing items must be unique or a ValueError is raised.
+class or None, or a TypeError is raised.  The values of the
+key property on all existing items must be unique or a
+ValueError is raised.
 """
 def getkey(self):
-"""Return the name of the key property for this class or None."""
+"""Return the name of the key property for this class or
+None.
+"""
 def lookup(self, keyvalue):
-"""Locate a particular item by its key property and return its id.
+"""Locate a particular item by its key property and return
+its id.
-If this class has no key property, a TypeError is raised.  If the
-'keyvalue' matches one of the values for the key property among
+If this class has no key property, a TypeError is raised.
-the items in this class, the matching item's id is returned;
+If the 'keyvalue' matches one of the values for the key
-otherwise a KeyError is raised.
+property among the items in this class, the matching item's
+id is returned; otherwise a KeyError is raised.
 """
 def find(self, propname, itemid):
-"""Get the ids of items in this class which link to the given items.
+"""Get the ids of items in this class which link to the
+given items.
-'propspec' consists of keyword args propname={itemid:1,}
-'propname' must be the name of a property in this class, or a
+'propspec' consists of keyword args propname={itemid:1,}
-KeyError is raised.  That property must be a Link or Multilink
+'propname' must be the name of a property in this class, or
-property, or a TypeError is raised.
+a KeyError is raised.  That property must be a Link or
+Multilink property, or a TypeError is raised.
-Any item in this class whose 'propname' property links to any of the
-itemids will be returned. Used by the full text indexing, which
+Any item in this class whose 'propname' property links to
-knows that "foo" occurs in msg1, msg3 and file7, so we have hits
+any of the itemids will be returned. Used by the full text
-on these issues:
+indexing, which knows that "foo" occurs in msg1, msg3 and
+file7, so we have hits on these issues:
 db.issue.find(messages={'1':1,'3':1}, files={'7':1})
 """
 def filter(self, search_matches, filterspec, sort, group):
-''' Return a list of the ids of the active items in this class that
+""" Return a list of the ids of the active items in this
-match the 'filter' spec, sorted by the group spec and then the
+class that match the 'filter' spec, sorted by the group spec
-sort spec.
+and then the sort spec.
-'''
+"""
 def list(self):
-"""Return a list of the ids of the active items in this class."""
+"""Return a list of the ids of the active items in this
+class.
+"""
 def count(self):
 """Get the number of items in this class.
-If the returned integer is 'numitems', the ids of all the items
+If the returned integer is 'numitems', the ids of all the
-in this class run from 1 to numitems, and numitems+1 will be the
+items in this class run from 1 to numitems, and numitems+1
-id of the next item to be created in this class.
+will be the id of the next item to be created in this class.
 """
 # Manipulating properties:
 def getprops(self):
-"""Return a dictionary mapping property names to property objects."""
+"""Return a dictionary mapping property names to property
+objects.
+"""
 def addprop(self, **properties):
 """Add properties to this class.
-The keyword arguments in 'properties' must map names to property
+The keyword arguments in 'properties' must map names to
-objects, or a TypeError is raised.  None of the keys in 'properties'
+property objects, or a TypeError is raised.  None of the
-may collide with the names of existing properties, or a ValueError
+keys in 'properties' may collide with the names of existing
-is raised before any properties have been added.
+properties, or a ValueError is raised before any properties
+have been added.
 """
 def getitem(self, itemid, cache=1):
-''' Return a Item convenience wrapper for the item.
+""" Return a Item convenience wrapper for the item.
-'itemid' must be the id of an existing item of this class or an
+'itemid' must be the id of an existing item of this class or
-IndexError is raised.
+an IndexError is raised.
-'cache' indicates whether the transaction cache should be queried
+'cache' indicates whether the transaction cache should be
-for the item. If the item has been modified and you need to
+queried for the item. If the item has been modified and you
-determine what its values prior to modification are, you need to
+need to determine what its values prior to modification are,
-set cache=0.
+you need to set cache=0.
-'''
+"""
 class Item:
-''' A convenience wrapper for the given item. It provides a mapping
+""" A convenience wrapper for the given item. It provides a
-interface to a single item's properties
+mapping interface to a single item's properties
-'''
+"""
 Hyperdatabase Implementations
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Hyperdatabase implementations exist to create the interface described in
 the `hyperdb interface specification`_ over an existing storage
 mechanism. Examples are relational databases, \*dbm key-value databases,
 and so on.
 Several implementations are provided - they belong in the
-roundup.backends package.
+``roundup.backends`` package.
 Application Example
 ~~~~~~~~~~~~~~~~~~~
 3
 >>> db.issue.create(title="arguments", status=2)
 4
 >>> db.issue.create(title="abuse", status=1)
 5
->>> hyperdb.Class(db, "user", username=hyperdb.Key(), password=hyperdb.String())
+>>> hyperdb.Class(db, "user", username=hyperdb.Key(),
+... password=hyperdb.String())
 <hyperdb.Class "user">
 >>> db.issue.addprop(fixer=hyperdb.Link("user"))
 >>> db.issue.getprops()
 {"title": <hyperdb.String>, "status": <hyperdb.Link to "status">,
 "user": <hyperdb.Link to "user">}
 >>> db.issue.get(5, "title")
 "abuse"
 >>> db.issue.find("status", db.status.lookup("in-progress"))
 [2, 4, 5]
 >>> db.issue.history(5)
-[(<Date 2000-06-28.19:09:43>, "ping", "create", {"title": "abuse", "status": 1}),
+[(<Date 2000-06-28.19:09:43>, "ping", "create", {"title": "abuse",
+"status": 1}),
 (<Date 2000-06-28.19:11:04>, "ping", "set", {"status": 2})]
 >>> db.status.history(1)
 [(<Date 2000-06-28.19:09:43>, "ping", "link", ("issue", 5, "status")),
 (<Date 2000-06-28.19:11:04>, "ping", "unlink", ("issue", 5, "status"))]
 >>> db.status.history(2)
 The Roundup database layer is implemented on top of the hyperdatabase
 and mediates calls to the database. Some of the classes in the Roundup
 database are considered issue classes. The Roundup database layer adds
 detectors and user items, and on issues it provides mail spools, nosy
 lists, and superseders.
 Reserved Classes
 ~~~~~~~~~~~~~~~~
 Internal to this layer we reserve three special classes of items that
 The "author" property indicates the author of the message (a "user" item
 must exist in the hyperdatabase for any messages that are stored in the
 system). The "summary" property contains a summary of the message for
 display in a message index.
 Files
 """""
 Submitted files are represented by hyperdatabase items of class "file".
 Like e-mail messages, the file content is stored in files outside the
 type=hyperdb.String())
 The "user" property indicates the user who submitted the file, the
 "name" property holds the original name of the file, and the "type"
 property holds the MIME type of the file as received.
 Issue Classes
 ~~~~~~~~~~~~~
 All issues have the following standard properties:
 made available. The value of the "creation" property is the date when an
 issue was created, and the value of the "activity" property is the date
 when any property on the issue was last edited (equivalently, these are
 the dates on the first and last records in the issue's journal).
 Roundupdb Interface Specification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The interface to a Roundup database delegates most method calls to the
 hyperdatabase, except for the following changes and additional methods::
 ~~~~~~~~~~~~~~
 The default schema included with Roundup turns it into a typical
 software bug tracker.  The database is set up like this::
-pri = Class(db, "priority", name=hyperdb.String(), order=hyperdb.String())
+pri = Class(db, "priority", name=hyperdb.String(),
+order=hyperdb.String())
 pri.setkey("name")
 pri.create(name="critical", order="1")
 pri.create(name="urgent", order="2")
 pri.create(name="bug", order="3")
 pri.create(name="feature", order="4")
 pri.create(name="wish", order="5")
-stat = Class(db, "status", name=hyperdb.String(), order=hyperdb.String())
+stat = Class(db, "status", name=hyperdb.String(),
+order=hyperdb.String())
 stat.setkey("name")
 stat.create(name="unread", order="1")
 stat.create(name="deferred", order="2")
 stat.create(name="chatting", order="3")
 stat.create(name="need-eg", order="4")
 first-stage submission, but it could be made just as easy with the
 addition of a convenience function like Choice for setting up the
 "priority" and "status" classes::
 def Choice(name, *options):
-cl = Class(db, name, name=hyperdb.String(), order=hyperdb.String())
+cl = Class(db, name, name=hyperdb.String(),
+order=hyperdb.String())
 for i in range(len(options)):
 cl.create(name=option[i], order=i)
 return hyperdb.Link(name)
 If none of the auditors raises an exception, the database proceeds to
 carry out the operation.  After it's done, it then calls all of the
 *reactors* that have been registered for the operation.
 Detector Interface Specification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The ``audit()`` and ``react()`` methods register detectors on a given
 class of items::
 For a ``set()`` operation, ``olddata`` contains the names and previous
 values of properties that were changed.
 For a ``retire()`` or ``restore()`` operation, ``itemid`` is the id of
 the retired or restored item and ``olddata`` is None.
 Detector Example
 ~~~~~~~~~~~~~~~~
 Here is an example of detectors written for a hypothetical
 "for a project that has already been approved."
 old = cl.get(id, "approvals")
 new = newdata["approvals"]
 for uid in old:
 if uid not in new and uid != db.getuid():
-raise Reject, "You can't remove other users from the "
+raise Reject, "You can't remove other users from " \
-"approvals list; you can only remove yourself."
+"the approvals list; you can only remove " \
+"yourself."
 for uid in new:
 if uid not in old and uid != db.getuid():
-raise Reject, "You can't add other users to the approvals "
+raise Reject, "You can't add other users to the " \
-"list; you can only add yourself."
+"approvals list; you can only add yourself."
-# When three people have approved a project, change its
+# When three people have approved a project, change its status from
-# status from "pending" to "approved".
+# "pending" to "approved".
 def approve_project(db, cl, id, olddata):
-if olddata.has_key("approvals") and len(cl.get(id, "approvals")) == 3:
+if (olddata.has_key("approvals") and
+len(cl.get(id, "approvals")) == 3):
 if cl.get(id, "status") == db.status.lookup("pending"):
 cl.set(id, status=db.status.lookup("approved"))
 def init(db):
 db.project.audit("set", check_approval)
 are submitted by sending in e-mail with an attached file, and we want to
 ensure that there are text/plain attachments on the message.  The
 maintainer of the package can then apply the patch by setting its status
 to "applied"::
-# Only accept attempts to create new patches that come with patch files.
+# Only accept attempts to create new patches that come with patch
+# files.
 def check_new_patch(db, cl, id, newdata):
 if not newdata["files"]:
 raise Reject, "You can't submit a new patch without " \
 "attaching a patch file."
 for fileid in newdata["files"]:
 if db.file.get(fileid, "type") != "text/plain":
-raise Reject, "Submitted patch files must be text/plain."
+raise Reject, "Submitted patch files must be " \
+"text/plain."
-# When the status is changed from "approved" to "applied", apply the patch.
+# When the status is changed from "approved" to "applied", apply the
+# patch.
 def apply_patch(db, cl, id, olddata):
-if cl.get(id, "status") == db.status.lookup("applied") and \
+if (cl.get(id, "status") == db.status.lookup("applied") and
-olddata["status"] == db.status.lookup("approved"):
+olddata["status"] == db.status.lookup("approved")):
 # ...apply the patch...
 def init(db):
 db.patch.audit("create", check_new_patch)
 db.patch.react("set", apply_patch)
 The command interface is a very simple and minimal interface, intended
 only for quick searches and checks from the shell prompt. (Anything more
 interesting can simply be written in Python using the Roundup database
 module.)
 Command Interface Specification
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 A single command, roundup, provides basic access to the hyperdatabase
 from the command line::
 listed items.
 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 -list) option.
 Usage Example
 ~~~~~~~~~~~~~
 To find all messages regarding in-progress issues that contain the word
 The Roundup system must be assigned an e-mail address at which to
 receive mail.  Messages should be piped to the Roundup mail-handling
 script by the mail delivery system (e.g. using an alias beginning with
 "|" for sendmail).
 Message Processing
 ~~~~~~~~~~~~~~~~~~
 Incoming messages are examined for multiple parts. In a multipart/mixed
 set() method to add the message to the issue's spool; in the second case
 we are calling the create() method to create a new item).  If an auditor
 raises an exception, the original message is bounced back to the sender
 with the explanatory message given in the exception.
 Nosy Lists
 ~~~~~~~~~~
 A standard detector is provided that watches for additions to the
 "messages" property.  When a new message is added, the detector sends it
 to the "recipients" property on the message, so multiple copies of a
 message are never sent to the same user.  The journal recorded by the
 hyperdatabase on the "recipients" property then provides a log of when
 the message was sent to whom.
 Setting Properties
 ~~~~~~~~~~~~~~~~~~
 The e-mail interface also provides a simple way to set properties on
 issues.  At the end of the subject line, ``propname=value`` pairs can be
 The user interface is constructed from a number of template files
 containing mostly HTML.  Among the HTML tags in templates are
 interspersed some nonstandard tags, which we use as placeholders to be
 replaced by properties and their values.
 Views and View Specifiers
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 There are two main kinds of views: *index* views and *issue* views. An
 construct a particular view. It goes after the URL to the Roundup CGI
 script or the web server to form the complete URL to a view.  When the
 result of selecting a link or submitting a form takes the user to a new
 view, the Web browser should be redirected to a canonical location
 containing a complete view specifier so that the view can be bookmarked.
 Displaying Properties
 ~~~~~~~~~~~~~~~~~~~~~
 Properties appear in the user interface in three contexts: in indices,
 An index view contains two sections: a filter section and an index
 section. The filter section provides some widgets for selecting which
 issues appear in the index.  The index section is a table of issues.
 Index View Specifiers
 """""""""""""""""""""
 An index view specifier looks like this (whitespace has been added for
 clarity)::
 Here's an example of a basic editor template::
 <table>
 <tr>
-<td colspan=2 tal:content="python:context.title.field(size='60')"></td>
+<td colspan=2
+tal:content="python:context.title.field(size='60')"></td>
 </tr>
 <tr>
 <td tal:content="context/fixer/field"></td>
 <td tal:content="context/status/menu"></td>
 </tr>
 If a note is given in the ":note" field, the note is appended to the
 description.  The message is then added to the issue's message spool
 (thus triggering the standard detector to react by sending out this
 message to the nosy list).
 Spool Section
 """""""""""""
 The spool section lists messages in the issue's "messages" property.
 The index of messages displays the "date", "author", and "summary"
 to perform some action::
 if db.security.hasPermission('issue', 'Edit', userid):
 # all ok
-if db.security.hasItemPermission('issue', itemid, assignedto=userid):
+if db.security.hasItemPermission('issue', itemid,
+assignedto=userid):
 # all ok
 Code in the core will make use of these methods, as should code in
 auditors in custom templates. The HTML templating may access the access
 controls through the *user* attribute of the *request* variable. It
 Anonymous Users
 ~~~~~~~~~~~~~~~
-The "anonymous" user must always exist, and defines the access permissions for
+The "anonymous" user must always exist, and defines the access
-anonymous users. Unknown users accessing Roundup through the web or email
+permissions for anonymous users. Unknown users accessing Roundup through
-interfaces will be logged in as the "anonymous" user.
+the web or email interfaces will be logged in as the "anonymous" user.
 Use Cases
 ~~~~~~~~~
 My thanks are due to Christy Heyl for reviewing and contributing
 suggestions to this paper and motivating me to get it done, and to Jesse
 Vincent, Mark Miller, Christopher Simons, Jeff Dunmall, Wayne Gramlich,
 and Dean Tribble for their assistance with the first-round submission.
 Changes to this document
 ------------------------
 - Added Boolean and Number types
 - Added section Hyperdatabase Implementations

Mercurial > p > roundup > code

comparison doc/design.txt @ 1711:3c3e44aacdb4