relisp 0.9.0

data/src/relisp.el

@@ -0,0 +1,264 @@
+;;; relisp.el --- library for ruby/elisp interaction
+
+;; Copyright (C) 2009 <don@ohspite.net>
+
+;; This file is part of Relisp.
+
+;; Relisp is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2 of the License, or
+;; (at your option) any later version.
+
+;; Relisp is distributed in the hope that it will be useful, but
+;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;; General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program; if not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+;; 02110-1301 USA
+
+
+;; TODO:
+;; signal errors when ruby returns an error?
+
+
+;;; first, some general string functions
+
+(defun relisp-trim-leading-whitespace (str)
+  "Remove leading whitespace characters from STR."
+  (let ((s (if (symbolp str)(symbol-name str) str))
+	(whitespace-regexp "\\( \\|\f\\|\t\\|\n\\)"))
+    (save-excursion
+      (while (and
+	      (not (null (string-match (concat "^" whitespace-regexp) s)))
+	      (> (length s) (string-match (concat "^" whitespace-regexp) s)))
+	(setq s (replace-match "" t nil s))))
+    s))
+
+(defun relisp-trim-trailing-whitespace (str)
+  "Remove trailing whitespace characters from STR."
+  (let ((s (if (symbolp str)(symbol-name str) str))
+	(whitespace-regexp "\\( \\|\f\\|\t\\|\n\\)"))
+    (save-excursion
+      (while (and
+	      (not (null (string-match (concat whitespace-regexp "$") s)))
+	      (> (length s) (string-match (concat whitespace-regexp "$") s)))
+	(setq s (replace-match "" t nil s))))
+    s))
+
+(defun relisp-strip (str)
+  "Remove leading and trailing whitespace from STR."
+  (relisp-trim-leading-whitespace (relisp-trim-trailing-whitespace str)))
+
+;;; now real stuff
+
+(defvar relisp-slave-name "relisp-slave" "Name of the relisp ruby slave process.")
+(defvar relisp-buffer-name "*Relisp*" "Name of the relisp output buffer.")
+
+;; to prohibit free variable warnings
+(defvar relisp-emacs-master-p t)
+(defvar relisp-slave-process)
+(defvar relisp-ruby-output)
+(defvar relisp-question-code)
+(defvar relisp-answer-code)
+(defvar relisp-error-code)
+(defvar relisp-ruby-return)
+(defvar relisp-previous-result)
+
+(defun relisp-log (text)
+  "Insert TEXT at the end of `relisp-buffer-name', unless emacs is the slave."
+  (when relisp-emacs-master-p
+    (get-buffer-create relisp-buffer-name)
+    (unless (string-match (relisp-endofmessage-regexp) (relisp-strip text))
+      (set-buffer relisp-buffer-name)
+      (goto-char (point-max))
+      (insert text "\n"))))
+
+(defun relisp-write-to-ruby (message)
+  "Send MESSAGE to the ruby process."
+  (if relisp-emacs-master-p
+      (process-send-string relisp-slave-process (concat message "\n"))
+    (message message)))
+
+(defun relisp-read-from-ruby nil
+  "Accept ruby input, stopping at a match to `relisp-endofmessage-regexp'."
+  (if relisp-emacs-master-p
+      (relisp-accept-slave-output)
+    (relisp-accept-master-output)))
+    
+(defun relisp-accept-slave-output nil
+  "Accept a full ruby message when ruby is the slave process."
+  (while (and (relisp-slave-alive-p) 
+	      (null (string-match (relisp-endofmessage-regexp)
+				  relisp-ruby-output)))
+    (accept-process-output))
+  (let ((val relisp-ruby-output))
+    (setq relisp-ruby-output "")
+    val))
+
+(defun relisp-accept-master-output nil
+  "Accept a full ruby message when emacs is the slave process."
+  (let ((output "") 
+	(output-line ""))
+    (while (null (string-match (relisp-endofmessage-regexp) output-line))
+      (setq output-line (read-from-minibuffer ""))
+      (setq output (concat output output-line)))
+    output))
+
+(defun relisp-endofmessage-regexp nil
+  "Return a regexp that matches codes indicating a message termination."
+  (concat "\\(" relisp-question-code 
+	  "\\|" relisp-answer-code 
+	  "\\|" relisp-error-code
+	  "\\)" 
+	  "[[:space:]]*"))
+
+(defun ruby-eval (ruby-code)
+  "Have ruby evaluate RUBY-CODE and return the result.
+The result is an elisp object equivalent to the ruby result of
+RUBY-CODE.  Reads input from the minibuffer unless an argument is
+given."
+  (interactive "sruby> ")
+  (let (message result)
+    (if (and relisp-emacs-master-p (not (relisp-slave-alive-p)))
+	(relisp-start-slave))
+    (relisp-log (concat "lisp?> " ruby-code))
+    (relisp-write-to-ruby (relisp-form-question ruby-code))
+    (setq message (relisp-read-from-ruby))
+    (while (string-match relisp-question-code message)
+      (relisp-answer-ruby message)
+      (setq message (relisp-read-from-ruby)))
+    (setq relisp-ruby-return (relisp-strip (car (split-string message relisp-answer-code))))
+    (relisp-log (concat "ruby=> " relisp-ruby-return "\n"))
+    (setq result (if (string-match (concat "\n?" relisp-error-code "[[:space:]]*") relisp-ruby-return)
+		     (concat "RUBY ERROR: " (replace-match "" nil t relisp-ruby-return))
+		   (eval (read (relisp-trim-trailing-whitespace relisp-ruby-return)))))
+    (if (interactive-p) 
+	(message (prin1-to-string result)))
+    result))
+
+(defun relisp-answer-ruby (question)
+  "Evaluate the QUESTION from ruby and send ruby the result."
+  (setq question (relisp-strip (car (split-string question relisp-question-code))))
+  (relisp-log (concat "ruby?> " question))
+  (setq question (read question))
+  (condition-case error-description
+      (progn 
+	(set relisp-previous-result (eval question))
+	(relisp-log (concat "lisp=> " (prin1-to-string (type-of (eval relisp-previous-result)))))
+	(relisp-log (concat " ...   " (prin1-to-string (eval relisp-previous-result))))
+	(relisp-write-to-ruby (prin1-to-string (type-of (eval relisp-previous-result))))
+	(relisp-write-to-ruby (relisp-form-answer (eval relisp-previous-result))))
+    (error (relisp-write-to-ruby 
+	    (relisp-form-error
+	     (error-message-string error-description))))))
+
+(defun relisp-form-question (code)
+  "Return a string that tells ruby to evaluate CODE."
+  (unless (stringp code)
+    (setq code (prin1-to-string code)))
+  (concat code "\n" relisp-question-code))
+
+(defun relisp-form-answer (code)
+  "Return a string that tells ruby that CODE is the answer to its query."
+  (setq code (prin1-to-string code))
+  (concat code "\n" relisp-answer-code))
+
+(defun relisp-form-error (code)
+  "Return a string that tells ruby that CODE is an error message."
+  (setq code (prin1-to-string code))
+  (concat code "\n" relisp-error-code))
+
+(defun relisp-to-ruby (object)
+  "Return a string that, when evaluated in ruby, results in OBJECT."
+  (let ((var (ruby-eval "new_elisp_variable")))
+    (set var object)
+    (concat "elisp_eval('" (prin1-to-string var) "')")))
+
+(defun relisp-start-slave nil
+  "Start a ruby slave process to do emacs's bidding.
+If `relisp-ruby-slave-path' is bound, then that file is read and
+the Relisp::RubySlave object must be started there.  Otherwise
+emacs starts a ruby process and starts a RubySlave on its own."
+  (interactive)
+  (setq relisp-emacs-master-p t)
+  (relisp-stop-slave)
+  (setq relisp-ruby-output "")
+  (if (and (boundp 'relisp-ruby-slave-path) (file-exists-p relisp-ruby-slave-path))
+      (setq relisp-slave-process (start-process relisp-slave-name nil "ruby" relisp-ruby-slave-path))
+    (setq relisp-slave-process (start-process relisp-slave-name nil
+					      "ruby" 
+					      "-x"))
+    (process-send-string relisp-slave-name 
+			 (concat "#! ruby \n"
+				 "$:.unshift File.join(File.dirname('" (symbol-file 'relisp-slave-name) "'), '../lib')\n"
+				 "require 'rubygems'\n" 
+				 "require 'relisp'\n" 
+				 "Relisp::RubySlave.new.start\n"
+				 "__END__\n")))
+  (set-process-filter relisp-slave-process 'relisp-slave-output-filter)
+  (relisp-write-to-ruby "")
+  (while (null (string-match "\n" relisp-ruby-output))
+    (accept-process-output))
+  (setq relisp-answer-code (relisp-strip relisp-ruby-output))
+  (setq relisp-ruby-output "")
+  (relisp-write-to-ruby "")
+  (while (null (string-match "\n" relisp-ruby-output))
+    (accept-process-output))
+  (setq relisp-question-code (relisp-strip relisp-ruby-output))
+  (setq relisp-ruby-output "")
+  (relisp-write-to-ruby "")
+  (while (null (string-match "\n" relisp-ruby-output))
+    (accept-process-output))
+  (setq relisp-error-code (relisp-strip relisp-ruby-output))
+  (setq relisp-ruby-output "")
+  (relisp-write-to-ruby "")
+  (while (null (string-match "\n" relisp-ruby-output))
+    (accept-process-output))
+  (setq relisp-previous-result (read (relisp-strip relisp-ruby-output)))
+  (setq relisp-ruby-output "")
+  relisp-slave-process)
+
+(defun relisp-become-slave nil
+  "Convert the emacs process into a slave.  Only called by ruby."
+  (setq relisp-emacs-master-p nil)
+  ;; get constants
+  (message "SEND CONSTANTS")
+  (message "(prompt for answer code)")
+  (setq relisp-answer-code (read-from-minibuffer ""))
+  (message "(prompt for question code)")
+  (setq relisp-question-code (read-from-minibuffer ""))
+  (message "(prompt for error code)")
+  (setq relisp-error-code (read-from-minibuffer ""))
+  (message "(prompt for previous result variable)")
+  (setq relisp-previous-result (read (read-from-minibuffer "")))
+  (let (input input-line)
+    (while t ;; loop is only a CL function, I guess
+      (setq input "")
+      (setq input-line "")
+      (while (null (string-match relisp-question-code (relisp-strip input-line)))
+	(setq input-line (read-from-minibuffer ""))
+	(setq input (concat input input-line)))
+      (relisp-answer-ruby input))))
+
+
+(defun relisp-slave-output-filter (process output-line)
+  "Listen to PROCESS and add each OUTPUT-LINE to `relisp-ruby-output'."
+  (setq relisp-ruby-output (concat relisp-ruby-output output-line)))
+
+(defun relisp-stop-slave nil
+  "Kill the ruby slave process."
+  (if (boundp 'relisp-slave-process)
+      (delete-process relisp-slave-process)))
+
+(defun relisp-slave-alive-p nil
+  "Return t if the ruby slave is alive and well."
+  (and (boundp 'relisp-slave-process) 
+       (equal (process-status relisp-slave-process) 'run)
+       (boundp 'relisp-question-code)
+       (boundp 'relisp-answer-code)
+       (boundp 'relisp-error-code)))
+
+(provide 'relisp)

data/tasks/ann.rake

@@ -0,0 +1,80 @@
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,20 @@
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF

data/tasks/gem.rake

@@ -0,0 +1,201 @@
+
+require 'find'
+require 'rake/packagetask'
+require 'rubygems/user_interaction'
+require 'rubygems/builder'
+
+module Bones
+class GemPackageTask < Rake::PackageTask
+  # Ruby GEM spec containing the metadata for this package.  The
+  # name, version and package_files are automatically determined
+  # from the GEM spec and don't need to be explicitly provided.
+  #
+  attr_accessor :gem_spec
+
+  # Tasks from the Bones gem directory
+  attr_reader :bones_files
+
+  # Create a GEM Package task library.  Automatically define the gem
+  # if a block is given.  If no block is supplied, then +define+
+  # needs to be called to define the task.
+  #
+  def initialize(gem_spec)
+    init(gem_spec)
+    yield self if block_given?
+    define if block_given?
+  end
+
+  # Initialization tasks without the "yield self" or define
+  # operations.
+  #
+  def init(gem)
+    super(gem.name, gem.version)
+    @gem_spec = gem
+    @package_files += gem_spec.files if gem_spec.files
+    @bones_files = []
+
+    local_setup = File.join(Dir.pwd, %w[tasks setup.rb])
+    if !test(?e, local_setup)
+      Dir.glob(::Bones.path(%w[lib bones tasks *])).each {|fn| bones_files << fn}
+    end
+  end
+
+  # Create the Rake tasks and actions specified by this
+  # GemPackageTask.  (+define+ is automatically called if a block is
+  # given to +new+).
+  #
+  def define
+    super
+    task :prereqs
+    task :package => ['gem:prereqs', "#{package_dir_path}/#{gem_file}"]
+    file "#{package_dir_path}/#{gem_file}" => [package_dir_path] + package_files + bones_files do
+      when_writing("Creating GEM") {
+        chdir(package_dir_path) do
+          Gem::Builder.new(gem_spec).build
+          verbose(true) {
+            mv gem_file, "../#{gem_file}"
+          }
+        end
+      }
+    end
+
+    file package_dir_path => bones_files do
+      mkdir_p package_dir rescue nil
+
+      gem_spec.files = (gem_spec.files +
+          bones_files.map {|fn| File.join('tasks', File.basename(fn))}).sort
+
+      bones_files.each do |fn|
+        base_fn = File.join('tasks', File.basename(fn))
+        f = File.join(package_dir_path, base_fn)
+        fdir = File.dirname(f)
+        mkdir_p(fdir) if !File.exist?(fdir)
+        if File.directory?(fn)
+          mkdir_p(f)
+        else
+          raise "file name conflict for '#{base_fn}' (conflicts with '#{fn}')" if test(?e, f)
+          safe_ln(fn, f)
+        end
+      end
+    end
+  end
+  
+  def gem_file
+    if @gem_spec.platform == Gem::Platform::RUBY
+      "#{package_name}.gem"
+    else
+      "#{package_name}-#{@gem_spec.platform}.gem"
+    end
+  end
+end  # class GemPackageTask
+end  # module Bones
+
+namespace :gem do
+
+  PROJ.gem._spec = Gem::Specification.new do |s|
+    s.name = PROJ.name
+    s.version = PROJ.version
+    s.summary = PROJ.summary
+    s.authors = Array(PROJ.authors)
+    s.email = PROJ.email
+    s.homepage = Array(PROJ.url).first
+    s.rubyforge_project = PROJ.rubyforge.name
+
+    s.description = PROJ.description
+
+    PROJ.gem.dependencies.each do |dep|
+      s.add_dependency(*dep)
+    end
+
+    PROJ.gem.development_dependencies.each do |dep|
+      s.add_development_dependency(*dep)
+    end
+
+    s.files = PROJ.gem.files
+    s.executables = PROJ.gem.executables.map {|fn| File.basename(fn)}
+    s.extensions = PROJ.gem.files.grep %r/extconf\.rb$/
+
+    s.bindir = 'bin'
+    dirs = Dir["{#{PROJ.libs.join(',')}}"]
+    s.require_paths = dirs unless dirs.empty?
+
+    incl = Regexp.new(PROJ.rdoc.include.join('|'))
+    excl = PROJ.rdoc.exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
+    excl = Regexp.new(excl.join('|'))
+    rdoc_files = PROJ.gem.files.find_all do |fn|
+                   case fn
+                   when excl; false
+                   when incl; true
+                   else false end
+                 end
+    s.rdoc_options = PROJ.rdoc.opts + ['--main', PROJ.rdoc.main]
+    s.extra_rdoc_files = rdoc_files
+    s.has_rdoc = true
+
+    if test ?f, PROJ.test.file
+      s.test_file = PROJ.test.file
+    else
+      s.test_files = PROJ.test.files.to_a
+    end
+
+    # Do any extra stuff the user wants
+    PROJ.gem.extras.each do |msg, val|
+      case val
+      when Proc
+        val.call(s.send(msg))
+      else
+        s.send "#{msg}=", val
+      end
+    end
+  end  # Gem::Specification.new
+
+  Bones::GemPackageTask.new(PROJ.gem._spec) do |pkg|
+    pkg.need_tar = PROJ.gem.need_tar
+    pkg.need_zip = PROJ.gem.need_zip
+  end
+
+  desc 'Show information about the gem'
+  task :debug => 'gem:prereqs' do
+    puts PROJ.gem._spec.to_ruby
+  end
+
+  desc 'Write the gemspec '
+  task :spec => 'gem:prereqs' do
+    File.open("#{PROJ.name}.gemspec", 'w') do |f|
+      f.write PROJ.gem._spec.to_ruby
+    end
+  end
+
+  desc 'Install the gem'
+  task :install => [:clobber, 'gem:package'] do
+    sh "#{SUDO} #{GEM} install --local pkg/#{PROJ.gem._spec.full_name}"
+
+    # use this version of the command for rubygems > 1.0.0
+    #sh "#{SUDO} #{GEM} install --no-update-sources pkg/#{PROJ.gem._spec.full_name}"
+  end
+
+  desc 'Uninstall the gem'
+  task :uninstall do
+    installed_list = Gem.source_index.find_name(PROJ.name)
+    if installed_list and installed_list.collect { |s| s.version.to_s}.include?(PROJ.version) then
+      sh "#{SUDO} #{GEM} uninstall --version '#{PROJ.version}' --ignore-dependencies --executables #{PROJ.name}"
+    end
+  end
+
+  desc 'Reinstall the gem'
+  task :reinstall => [:uninstall, :install]
+
+  desc 'Cleanup the gem'
+  task :cleanup do
+    sh "#{SUDO} #{GEM} cleanup #{PROJ.gem._spec.name}"
+  end
+end  # namespace :gem
+
+
+desc 'Alias to gem:package'
+task :gem => 'gem:package'
+
+task :clobber => 'gem:clobber_package'
+remove_desc_for_task 'gem:clobber_package'
+
+# EOF

data/tasks/git.rake

@@ -0,0 +1,40 @@
+
+if HAVE_GIT
+
+namespace :git do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  desc 'Show tags from the Git repository'
+  task :show_tags => 'git:prereqs' do |t|
+    puts %x/git tag/
+  end
+
+  desc 'Create a new tag in the Git repository'
+  task :create_tag => 'git:prereqs' do |t|
+    v = ENV['VERSION'] or abort 'Must supply VERSION=x.y.z'
+    abort "Versions don't match #{v} vs #{PROJ.version}" if v != PROJ.version
+
+    tag = "%s-%s" % [PROJ.name, PROJ.version]
+    msg = "Creating tag for #{PROJ.name} version #{PROJ.version}"
+
+    puts "Creating Git tag '#{tag}'"
+    unless system "git tag -a -m '#{msg}' #{tag}"
+      abort "Tag creation failed"
+    end
+
+    if %x/git remote/ =~ %r/^origin\s*$/
+      unless system "git push origin #{tag}"
+        abort "Could not push tag to remote Git repository"
+      end
+    end
+  end
+
+end  # namespace :git
+
+task 'gem:release' => 'git:create_tag'
+
+end  # if HAVE_GIT
+
+# EOF

data/tasks/manifest.rake

@@ -0,0 +1,48 @@
+
+require 'find'
+
+namespace :manifest do
+
+  desc 'Verify the manifest'
+  task :check do
+    fn = PROJ.manifest_file + '.tmp'
+    files = manifest_files
+
+    File.open(fn, 'w') {|fp| fp.puts files}
+    lines = %x(#{DIFF} -du #{PROJ.manifest_file} #{fn}).split("\n")
+    if HAVE_FACETS_ANSICODE and ENV.has_key?('TERM')
+      lines.map! do |line|
+        case line
+        when %r/^(-{3}|\+{3})/; nil
+        when %r/^@/; ANSICode.blue line
+        when %r/^\+/; ANSICode.green line
+        when %r/^\-/; ANSICode.red line
+        else line end
+      end
+    end
+    puts lines.compact
+    rm fn rescue nil
+  end
+
+  desc 'Create a new manifest'
+  task :create do
+    files = manifest_files
+    unless test(?f, PROJ.manifest_file)
+      files << PROJ.manifest_file
+      files.sort!
+    end
+    File.open(PROJ.manifest_file, 'w') {|fp| fp.puts files}
+  end
+
+  task :assert do
+    files = manifest_files
+    manifest = File.read(PROJ.manifest_file).split($/)
+    raise "ERROR: #{PROJ.manifest_file} is out of date" unless files == manifest
+  end
+
+end  # namespace :manifest
+
+desc 'Alias to manifest:check'
+task :manifest => 'manifest:check'
+
+# EOF

data/tasks/notes.rake

@@ -0,0 +1,27 @@
+
+if HAVE_BONES
+
+desc "Enumerate all annotations"
+task :notes do |t|
+  id = if t.application.top_level_tasks.length > 1
+    t.application.top_level_tasks.slice!(1..-1).join(' ')
+  end
+  Bones::AnnotationExtractor.enumerate(
+      PROJ, PROJ.notes.tags.join('|'), id, :tag => true)
+end
+
+namespace :notes do
+  PROJ.notes.tags.each do |tag|
+    desc "Enumerate all #{tag} annotations"
+    task tag.downcase.to_sym do |t|
+      id = if t.application.top_level_tasks.length > 1
+        t.application.top_level_tasks.slice!(1..-1).join(' ')
+      end
+      Bones::AnnotationExtractor.enumerate(PROJ, tag, id)
+    end
+  end
+end
+
+end  # if HAVE_BONES
+
+# EOF