Added .hooke.cfg to .hgignore.

The local config copy auto-generated by hooke.hooke.main().  We don't
want anyone adding this to the versioning system by accident.

Broke out Hooke.run and Hooke.run_lines into HookeRunner.

This allows the main process access to the command process' possibly
altered Hooke instance.  For example:
  >>> h = Hooke()
  >>> r = HookeRunner()
  >>> h = r.run_lines(h, ['load_playlist test/data/test'])
  >>> h = r.run_lines(h, ['curve_info --all=True'])
With the old implementation, second run_lines() call would fail
because the playlist was only loaded in the first command process'
Hooke instance, not the Hooke instance that the main (UI) process
held.

Pull Hooke.run*() multiprocessing setup/teardown into ._setup/_cleanup_run.

Limits code duplication between .run() and .run_lines().

Add hooke.playlist.NoteIndexList.__str__() method.

Now playlists etc. will flatten themselves to strings with:
  '...%s...' % instance.

Unset executible bits in curvetools.py and jumpstat.py permissions.

Ran update_copyright.py, updating all the copyright blurbs and adding AUTHORS.

Use ALIASES and AUTHOR_HACKS handling in update_copyright.update_authors.

The previously generated AUTHORS file was the raw list of VCS
commiters.

Updated copyright blurbs in all files to '# Copyright'

This tag will be replaced by update_copyright.py with the full
copyright blurb for each file.

Further author/year workarounds in update_copyright.py.

Add AUTHOR_HACKS and YEAR_HACKS to update_copyright.py

This works around holes in the versioning where files were initially
released before being added to the versioning system, or they were
never committed under the name of one of the authors.

Update canonical copyright names for 'illysam' and 'pancaldi.paulo'.

Also add the missing '.82' to Fabrizio's alias.

Fix some doctests in update_copyright.py.

And make some adjustments so that update_copyright.py can update its
own copyright blurb without changing anything else inside itself.

Rearrange license text and add update_copyright.py.

Following http://www.gnu.org/licenses/gpl-howto.html
  * Moved LGPLv3 text from LICENSE -> COPYING.LESSER
  * Brought in GPLv3 text -> COPYING

update_copyright.py automates the maitenance of boilerplate copyright
information at the head of every file.

Added integration test directory test/ and load_playlist test.

Run all integration tests with:
  nosetests --with-doctest --doctest-tests test/

Updated .hgignore to ignore documentation build files.

Added .hgignore masking *.pyc files

Added distutils-based setup.py.

Fix git->hg and wget -o -> -O in doc/install.txt snapshot command.

Path change because of Git->Mercurial migration.

wget
  -O --output-document    sets the document file.
  -o --output-file        sets the logfile.

Updated fork project info for Rolf and my branches in doc/install.txt.

I think I found where Rolf's code is (SVN illysam branch), and I
migrated my Git-versioned fork to Mercurial.

Add --script and --command to bin/hooke

Save playlist digest on loading.

The previous implementation felt that playlists were not saved
(.is_saved() -> False) when the playlists had not been altered since
loading.

We *don't* save the digest when we load from a string, because
that string is not necessarily on disk and we *do* want to save
it, even if the playlist hasn't change since loading.

I also removed the return bits, since FilePlaylist._from_xml_doc()
doesn't return anything.

Actually set self.name in hooke.playlist.FilePlaylist.set_path

Fix str() bug in hooke.ui.commandline.LocalExitCommand save msg.

Old implemtation crashed if Playlist.name was None.

Move hooke/test/default.000 -> test/data/picoforce.000

+ corresponding update to test/data/test.hkp.

Actually set self.path in hooke.playlist.FilePlaylist.set_path

Add all_drivers_callback to hooke.plugin.playlist.LoadCommand.

I can't imagine the user not wanting to use all available playlists.
They still can, but specifiying a sublist is now optional.

Fix typos in hooke.playlist.FilePlaylist.set_path

Fix bug in hooke.ui.commandline.DoCommand._check_argument_length() max_arg calculation.

Moved test and mfp_igor_scripts directories around

Split out "Troubleshooting" into doc/bugs.txt.

This section will probably grow ;).
+ other textual cleanups.

Fix doc/index.txt references to auto-generated pages

:ref:`~...` -> :ref:`...` following
  http://sphinx.pocoo.org/_sources/contents.txt

Documentation cleanups.

Specifically:
  * Escape *nix -> \*nix, because the bare * looks like an emphasis
    start mark.
  * Use :file:`...` to denote files.
  * Fix FHS reference '_ ..' -> '.. _'
  * Add a link to Sphinx's markup extensions.
  * Remove superfluous "Hooke" from section titles.
  * Use correct section linking:
      X.txt -> X
      :doc:`X`
    see
      http://sphinx.pocoo.org/concepts.html#document-names
      http://sphinx.pocoo.org/markup/inline.html#role-doc
  * Use two spaces (not one) at start of sentences.
  * `code` -> ``code`` (the way I had things originally :p).  See
      http://sphinx.pocoo.org/markup/inline.html#role-samp

Don't abbreviate multiprocessing.Queue in hacking.txt

Remove ~~ in info attribute reference of doc/hacking.txt

Fix hooke.utils -> hooke.util typo in doc/hacking.txt

Add :class: bit to many `...` escapes in hacking.txt and index.txt

Standardize example indentation to 4 spaces in doc/tutorial.txt

Sync doc/tutorial.txt splash text with hooke.ui.UserInterface._splash_text.

Also:
 * Flesh out doc/architecture.txt
 * Replace a number of '``' escapes with '`'.  My reStructuredText was
   rusty on the first pass through the documentation ;).

Nothing useful left in hooke_cli, removed.

More commands moved from hooke_cli to hooke.ui.gui.plotcommands stub

Moved config handling commands from hooke_cli to hooke.plugin.config.

Also:
  * Moved construct_graph and IsSubclass from hooke.plugin to
    hooke.util.pluggable to avoid import cycles and cleanup
    hooke.plugin.
  * Added hooke.interaction.ReloadUserInterfaceConfig to trigger UI
    reconfigure.
  * Added hooke.ui.UserInterface.reload_config (triggered by above).
  * Pass CommandLine instance to HookeCmd, so it can reconfigure
    the UI.

Moved printlist command from hooke_cli -> hooke.plugin.playlist.CurveListCommand.

Moved index command from hooke_cli -> hooke.plugin.playlist.IndexCommand.

Removed next/previous commands from hooke_cli

Superseded by hooke.plugin.playlist commands.

Moved plot commands from hooke_cli -> hooke.ui.gui.plotcommands stub.

Moved export command from hooke_cli -> hooke.ui.gui.export stub.

Moved txt command from hooke_cli -> hooke.plugin.curvetools stub.

Moved note handling commands to hooke.plugin.note.

Also:
  * Fixed graph dependency creation in hooke.plugin.construct_graph.
    The previous implemetation had Plugin instances as parents, not
    Node instances.
  * Moved a few builtin modules from hooke.plugin.PLUGIN_MODULES to
    .BUILTIN_MODULES.
  * Fixup unsaved playlist detection in
    hooke.ui.commandline.LocalExitCommand._run

notelog has been superseded by hooke.plugin.playlist.SaveCommand

The notes will be stored in Playlist.info['note'], and the info dict
is saved in the playlist file format.

Run hooke.command.Argument.callback every time (if defined).

The previous implemtation which only ran the callback if a value was
given was too confusing.

Also:
  * Added hooke.plugin.playlist.NoteFilterCommand.  In general, I
    think running commands this way is pretty awkward.  We should
    probably just use a Python interpreter instead of cmd.Cmd, but
    for now, NoteFilterCommand provides something like the old
    'copylog' functionality.
  * Removed a bunch of superseded code from hooke.hooke_cli.

Fix hooke.ui.commandline imports following hooke.interaction creation.

Moved hooke.libpeakspot -> hooke.plugin.peakspot

Moved hooke.formatter -> hooke.ui.gui.formatter.

The code seemed GUI-specific.

Moved Interaction related classes from hooke.command -> hooke.interaction.

Breaking them out makes hooke.command clearer for new readers.

Also moved remaining libhooke functionality ->
hooke.ui.gui.point_request, although it will need reworking (like the
rest of the stuff in hooke.ui.gui) once I finish the architecture
transition.

Removed hooke.liboutlet/.libviewer/.plugin.viewer.

Functionality superseded by hooke.ui.

Removed hooke.libinput

Functionality superseded by hooke.command.Request/.Response.

Use *_SETTING_SECTION in hooke.plugin/.driver/.ui for section name

Avoid constant duplication in code (brittle).

Removed hooke.hooke.TestHooke.

I couldn't find a flexible enough equality comparison between the two
Hooke instances.  It doesn't seem worth it to add .__eq__ or .__cmp__
methods to all of my classes just to test Queue-proof-ness.  Maybe I'm
just lazy...  Anyhow, the original problem case now works:

  $echo 'debug' | python bin/hooke
  This is Hooke, version 0.9.0.devel (Kenzo)

  COPYRIGHT
  ----
  hooke> <hooke.hooke.Hooke object at 0xb6a0bcac>
  Success
  ...

Fix problem in Queuing odict/HookeConfigParser.

I'm not sure why odict.__setstate__() is not being called before
.__setitem__(), but this hack seems to be a valid workaround.

Added hooke.config.TestHookeConfigParser

Used hooke.hooke.TestHooke to isolate Queue issue to
HookeConfigParser:

  ======================================================================
  ERROR: Ensure :class:`HookeConfigParser` is Queue-safe
  ----------------------------------------------------------------------
  Traceback (most recent call last):
    File "/tmp/hooke/hooke/config.py", line 270, in test_queue_safe
      b = q.get(a)
    File "/usr/lib/python2.6/multiprocessing/queues.py", line 91, in get
      res = self._recv()
    File "/tmp/hooke/hooke/compat/odict.py", line 214, in __setitem__
      self._keys.append(key)
  AttributeError: 'odict' object has no attribute '_keys'

Added hooke.hooke.TestHooke

Dash separators consistent with hooke.ui.UserInterface._splash_text().

'---' -> '----' in hooke.plugin.debug.VersionCommand.
'----' -> '----' in hooke.ui.commandline.HelpCommand.

Moved debuging commands from hooke_cli and plugin.system to plugin.debug.

Moved system commands from hooke_cli to plugin.system.

Added Argument.count handling to hooke.ui.commandline.

Rework hooke.command.Command.handle_arguments (again :p).

Previous implementation didn't set params[name] when
  num_provided == 0 and argument.callback != None

Adjust hooke.command.UncaughtException to properly handle pickle reconstruction.

multiprocessing.Queue pickles objects to send through its pipe, so our
objects must be capable of surving the pickling process unscathed.

Added interaction to hooke.ui.commandline.LocalCommandExit.

Also broke out commandline's exit and help commands.  They were
getting complicated enough to deserve their own classes.

Better solution to internal/external names via `name_fn`.

Use ._cl_name and ._cl_aliases instead of overwriting .name and .aliases.

We don't change the keys hardcoded into the Command._run methods, so
we need to keep the original names.  Hmm, I'll have to adjust
Command.help and Argument.help to use the external names...

Add hooke.playlist.NoteIndexList and refactor exception handling in commandline.

Highlights:
  * hooke.playlist classes now subclass the new hooke.playlist.NoteIndexList
  * hooke.plugin.cut.CurveArgument replaces previous _run hacking with
    a callback to initialize the default curve.x
  * hooke.ui.commandline.command_parser -> CommandLineParser.  The new
    class is cleaner, and raises exceptions rather than exiting.  We
    don't want Hooke dying until the user has time to clean up.

Pass Hooke instance to CommandEngine.run(), not UserInterface.run().

User interface just needs its configuration (already setup in
  Hooke.load_ui() -> ui.load_ui(self.config)
) and a read-only list of commands.  Giving the Hooke instance to
CommandEngine allows the commands to work on the Hooke instance
directly.  This makes user interfaces less intelligent (i.e. easier to
write), and more consistent (because they all depend on the same
commands engine.)

Don't crash when Command._run() raises an uncaught Exception.

Just print the traceback and move on.  This gives the user time to
exit gracefully (saving playlists etc.).

Argument parser now works for command execution as well (vs. just for help).

Added command parser to hooke.ui.commandline for argument listing.

help_* working in commandline UI.

Still to go:
  * DoCommand._parse_args
  * DoHelp._usage_string
  * CompleteCommand
  * Interactive communication between user and command

Added basic commandline framework to ui.commandline (using cmd.Cmd)

Finished off hooke.hooke and fleshed out hooke.ui.

Highlights:
  * New hooke.command for CommandExit (and subclasses), Command, and
    Argument.  For the same reason as hooke.playlist: keep core
    functionality out of hooke.plugin, which is only for the pluggable
    interface to that functionality.
  * New hooke.engine containing CommandEngine.  Not much going on
    here.  Perhaps I will merge it into hooke.command later...
  * New hooke.ui.commandline stub for 'command line' UI.
  * Filled in hooke.ui stub.
  * Added UI and CommandEngine handling to hooke.hooke.Hooke.
  * Added a new super-local '.hooke.cfg' to hooke.config.DEFAULT_PATHS.
    For project-specific hooke configuration?  Mostly to avoid suprising
    the user by clobbering ~/.hooke.cfg.
  * Fix expanduser bug in hooke.config.HookeConfigParser.write.
  * Fix super(AddCommand, self) -> super(AddGlobCommand, self) bug in
    hooke.plugin.playlist.AddGlobCommand.__init__.

Added hooke.plugin.playlist.AddGlobCommand.

This completes the rewrite of individual playlist handling.

Also:
  * Added hooke.plugin.playlist.FilePlaylist.set_path() to reduce
    duplicate code.

Oops, I'd forgotten to version the restored hooke.playlist module.

A number of minor documentation cleanups.

Updated to doc building framework.  Added Sphinx extensions and fixed genrst dependency

Minor fix to hooke.plugin.playlist.__doc__

Moved Playlist and FilePlaylist definitions back to hooke.playlist

We shouldn't define core classes in plugins.  This will make the
plugin clearer, separating the core functionality from the silly
plugin interface to that core functionality.  Such Builtins are useful
for the Hooke command line and GUIs, but not for people using Python
to import hooke directly.

Cleaned up Builtin handling and reduced driver/plugin duplication.

Moved hooke.playlist -> hooke.plugin.playlist and added hooke.plugin.Builtin.

Highlights:
  * Cleaner Playlist, with more consistent file format.
  * New "Builtin" class for required (core) commands.
  * Moved NotRecognized from hooke.driver -> hooke.curve to avoid
    import-order issues.  Now hooke.curve can be fully loaded before
    hooke.driver.
  * Moved hooke.curve.Data.notes -> hooke.curve.Data.info['note']
    for better consistency with Curve and Playlist.
  * Started cleaning up plugin loading into flexible functions.

Add Hooke.commands, a list of available commands

Ironed out kinks in plugin/driver loading and configuring.

Highlights:

  * Plugin/Driver.setting_section attribute so subclasses don't need
    to construct it on their own (duplicate effort, and so, error
    prone).
  * Fixed self.wrap = True -> self.wrap = wrap bug in
    hooke.config.Setting
  * No longer alter hooke.config.DEFAULT_SETTINGS in
    hooke.hooke.Hooke.__init__()
  * Filled in Hooke.load_plugins()/.load_drivers() stubs.
  * Removed deprecated Hooke.driver_default_settings().
  * Commented out a lot of the old HookeFrame code.  I'll delete
    it as I go through and implement its functionality.

Rework hooke.driver and hooke.driver.tutorial along the lines of hooke.plugin.

Many more drivers to refactor, but this is good enough to get me going
again with the core code.

Assorted changes so import hooke.plugin works ;).

Uncommenting the cut entry in PLUGIN_MODULES exposed a number of bugs
which I fixed:
  * def Plugin (object): -> class Plugin (object):
  * plugin initialization must occur *after* Command/Argument definition.
    That way the neccessary classes are defined when we go to load the
    plugin modules.
  * Broken default_settings() fixed.

Also did some docstring cleanup.

Moved hooke.libhookecurve -> hooke.curve and rewrote HookeCurve -> Curve class.

New class Data subclasses numpy.ndarray for faster data handling.

Changes:
  * hooke.libhookecurve.PlotObject -> hooke.ui.gui.plot.PlotObject
  * hooke.libhookecurve.Driver -> hooke.driver.Driver
  * Raise new exception hooke.driver.NotRecognized if no driver
    matches (vs. old print message and return false).
  * Curve stores data in a list (vs. old dict).  Often data order
    is important.  The names that used to key the data dict can
    now go into Data.info['name'].
  * HookeCurve.fits -> Curve.info['fits']
  * HookeCurve.plots is GUI data, but if the UI needs it, it should be
    stored in Curve.info['plots']
  * Since Curve.data is an array,
    HookeCurve.add_data() -> Curve.data.append(),
    HookeCurve.delete_data() -> Curve.data.remove(), and
    HookeCurve.set_data() -> Curve.data[i] = data

Converted hooke.plugin.cut to new Plugin architecture.

Use .type.upper() (vs. old .name.upper()) for Argument.metavar.

This conveys more information to the user
     output FILE
compared to the same word twice:
     output OUTPUT

Also rearranged some options.

Moved Argument and other class definitions after Command

Added Command and related classes to hooke.plugin

Based on my libbe.commands.base work for Bugs Everywhere.

Added hooke.plugin.Plugin.name attribute.

Also:
  * Reordered Plugin methods from first called -> last called.
  * Removed old Commands class.

Added tip-to-root/root-to-tip flexibility to hooke.util.graph

The old implementation only did tip-to-root.  The new default is
root-to-tip.

Added inclusion logic to hooke.plugin

Added the graph module I'd developed for Bugs-Everywhere

Beginning to rewrite Hooke to decouple from GUI.

This commit:
  * Started documenting with reStructuredText (for later use by Sphinx)
  * Added hooke.config module to handle configure files (via ConfigParser)
  * Added hooke.compat module to hold compatibility code
    (e.g. workarounds to allow Hooke to work on older Python versions).
  * Added config input/output to hooke.hooke.Hooke.
  * Stubbed out driver/plugin initialization in Hooke