- test.test_remote: added testcases for Request's diff method
- test.test_remote: test _attrib_filter in class ElementFactory
- osc.remote: added _attrib_filter method to class ElementFactory

It filters out all attributes with value None (an ideal implementation
would use an OrderedDict (makes testing easier/more predictable))
- osc.remote.RORemoteFile: fixed minor bug: use passed method instead of hardcoding 'GET'
- osc.remote.Request: implemented diff method
- test.test_remote: added testcase for Request's __cmp__ method
- osc.remote: added __cmp__ method to Request class
- test.test_oscargs: added another testcase for subclassing the OscArgs class

(this was introduced because there was a bug in the osc.oscargs code)
- osc.oscargs: fixed bug and added __contains__ and __iter__ methods to class ResolvedInfo

also changed behaviour of __getattr__ (that is ResolvedInfo can be treated like a dict)
- test.util.test_xpath: added additional testcases for the GeneratorDelegate and new testcases for the dummy method

Now it is possible to use an arbitrary expression as a "generator".
Additionally a dummy method was introduced in order to avoid "xp is None"
checks in the code:
Example/use case:
xp = None
for i in some_list:
    if xp is None:
        xp = xpb.foo[xpb.attr(i) == '2']
    else:
        xp = xp & xpb.foo[xpb.attr(i) == '2']

can be written as:
xp = xpb.dummy()
for i in some_list:
    xp = xp & xpb.foo[xpb.attr(i) == '2']
- osc.util.xpath: reworked GeneratorDelegate code and introduced new DummyExpression class

Now an arbitrary expression can be used as a "generator" (do not confuse with
python's generator objects)
- test.test_search: added initial testcases for the search module
- test.suite: added test_search module to the suite
- osc.search: added initial version of a search module
- osc.cli: added cli package

Added description module which can be used to define a argparse
ui in a descriptive manner. The syntax for defining a command is
similar to defining models in the django framework (that's what
inspired me).

Example:

OscCommand is a base class for all toplevel osc commands.

class Request(CommandDescription, OscCommand):
    """Show and modify requests."""
    cmd = 'request'

class RequestList(CommandDescription, Request):
    """List requests.

    By default open requests for a specific project or package will be
    listed.

    Examples:
    osc request list api://
    osc request list api://project
    osc request list api://project/package

    """
    cmd = 'list'
    args = 'api://project?/package?'
    opt_user = Option('U', 'user', 'list only requests for USER')
    opt_group = Option('G', 'group', 'list only requests for GROUP')
    opt_state = Option('s', 'state', 'list only requests with state STATE',
                       choices=['new', 'review', 'accepted', 'revoked',
                                'declined', 'superseded'], action='append',
                       default=['new', 'review'])
    func = call(request.list)

That is with the help of the inheritance hierarchy we can build a
command <-> subcommand hierarchy. For more details and examples
have a look at the following commits or at this blog post
http://lizards.opensuse.org/2012/08/07/gsoc-osc2-client-summary-of-week-11/
- osc.cli: added render module.

It provides a class to render templates.
- osc.cli: added cli module

The cli module acts the main entry point for the cli package.
- osc.cli.util: added initial util package.

So far it contains an env module which provides some functions to
run applications from the enviroment (for instance $PAGER or $EDITOR)
- osc.cli.request: added initial version of the "request" command