rap 0.12.0

data/History

@@ -0,0 +1,8 @@
+== 0.12.0 / 2009-02-17
+
+As of the 0.12.0 release, Tap is distributed as several independent modules.
+This is the rap module.  The core classes have been cleaned up significantly
+since the 0.11 series, and some changes are not backwards compatible.
+
+* Significant cleanup of declarations
+* Refactored Tap::Declarations as Rap::Declarations

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009, Regents of the University of Colorado.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,117 @@
+= {Rap (Rakish App)}[http://tap.rubyforge.org/rap]
+
+  rap v. a quick, sharp knock or blow
+  rakish adj. having a dashing, jaunty, or slightly disreputable quality or appearance
+
+A rakish extension to {Tap}[http://tap.rubyforge.org/rdoc].
+
+== Description
+
+Rap supercharges the syntax of Rake by adding configurations, extended
+documentation, and class-based tasks that are easy to test.
+
+Rap is a part of the {Tap-Suite}[http://tap.rubyforge.org/tap-suite].
+Check out these links for documentation, development, and bug tracking.
+
+* Website[http://tap.rubyforge.org]
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/9908-tap-task-application/tickets]
+* Github[http://github.com/bahuvrihi/tap/tree/master]
+* {Google Group}[http://groups.google.com/group/ruby-on-tap]
+
+== Usage
+
+Usage is much like {rake}[http://rake.rubyforge.org/]:
+
+  [Rapfile]
+  require 'rap/declarations'
+  include Rap::Declarations
+  
+  desc "your basic goodnight moon task"
+  
+  # Says goodnight with a configurable message.
+  task(:goodnight, :obj, :message => 'goodnight') do |task, args|
+    puts "#{task.message} #{args.obj}\n"
+  end
+  
+Now from the command line:
+
+  % rap goodnight moon
+  goodnight moon
+  
+  % rap goodnight world --message hello
+  hello world
+  
+  % rap goodnight --help
+  Goodnight -- your basic goodnight moon task
+  --------------------------------------------------------------------------------
+    Says goodnight with a configurable message.
+  --------------------------------------------------------------------------------
+  usage: rap goodnight OBJ
+
+  configurations:
+          --message MESSAGE
+
+  options:
+      -h, --help                       Print this help
+          --name NAME                  Specify a name
+          --use FILE                   Loads inputs from file
+
+For testing, load the Rapfile and access the task as a constant.
+
+  [test.rb]
+  load 'Rapfile'
+  require 'test/unit'
+  require 'stringio'
+  
+  class RapfileTest < Test::Unit::TestCase
+    def test_the_goodnight_task
+      $stdout = StringIO.new
+      
+      task = Goodnight.new
+      assert_equal 'goodnight', task.message
+      
+      task.process('moon')
+      assert_equal "goodnight moon", $stdout.string
+    end
+  end
+
+The test passes:
+
+  % ruby test.rb
+  Loaded suite test
+  Started
+  .
+  Finished in 0.004921 seconds.
+
+  1 tests, 2 assertions, 0 failures, 0 errors
+
+Generally speaking, the rap executable is a shorthand for 'tap run --' so you
+can use rap to quickly launch workflows as well.  See the 
+{Command}[link:files/doc/Command%20Reference.html] and 
+{Syntax}[link:files/doc/Syntax%20Reference.html] References for more information.
+
+=== Limitations
+
+Rap is not a pure replacement of Rake.  Rap does not support builds by default,
+classes like FileList are not included, and namespace lookup is slightly
+different (see the {Syntax Reference}[link:files/doc/Syntax%20Reference.html]).
+
+== Installation
+
+Rap is available as a gem on RubyForge[http://rubyforge.org/projects/tap].  Use:
+
+  % gem install rap
+
+Rap requires an updated version of RubyGems[http://docs.rubygems.org/] 
+(>= 1.2.0).  To check the version and update RubyGems:
+
+  % gem --version
+  % gem --update system
+    
+== Info 
+
+Copyright (c) 2009, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]
+

data/bin/rap

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# usage: rap taskname {options} [args]
+
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'rap/declarations'
+
+# setup the environment
+begin
+  
+  # handle super options
+  $DEBUG = true if ARGV.delete('-d-')
+  env = Tap::Exe.instantiate
+  env.unshift(Rap::Declarations.env)
+  
+  Dir.glob('[TtRr]apfile{,.rb}').each do |task_file|
+    task_file  = File.expand_path(task_file)
+    next unless File.file?(task_file)
+    
+    env.loads.unshift(task_file)
+  end
+  
+rescue(Tap::Env::ConfigError)
+  # catch errors and exit gracefully
+  # (errors usu from gem loading errors)
+  puts $!.message
+  exit(1)
+end
+
+#
+# setup after script
+#
+
+at_exit do
+  begin
+    eval(env.after) if env.after != nil
+  rescue(Exception)
+    puts "Error in after script."
+    env.handle_error($!)
+    exit(1)
+  end
+end
+
+#
+# run before script
+#
+
+begin
+  eval(env.before) if env.before != nil
+rescue(Exception)
+  puts "Error in before script."
+  env.handle_error($!)
+  exit(1)
+end 
+
+#
+# run rap
+#
+
+module Rap
+  autoload(:Rake, 'rap/rake')
+end
+
+begin
+  env.activate
+  
+  case ARGV[0]
+  when '--help', nil, '-T'
+    rap_template = %Q{<% if count > 1 && !entries.empty? %>
+<%= env_name %>:
+<% end %>
+<% entries.each do |name, const| %>
+<%   desc = if const.require_path == nil # should be a declaration %>
+<%     manifest = const.constantize.manifest %>
+<%     next if manifest == nil || manifest.empty? %>
+<%     manifest %>
+<%   else %>
+<%     const.document[const.name]['manifest'] %>
+<%   end %>
+  <%= name.ljust(width) %><%= desc.empty? ? '' : '  # ' %><%= desc %>
+<% end %>}
+
+    puts Lazydoc.usage(__FILE__)
+    puts
+    puts "===  tap tasks ==="
+    puts env.summarize(:tasks, rap_template)
+    puts
+    puts "=== rake tasks ==="
+    Rap::Rake.new.enq('-T')
+    Tap::App.instance.run
+    
+    # this is not currently reached as rake exits on -T
+    puts
+    puts "version #{Tap::VERSION} -- #{Tap::WEBSITE}"
+    exit
+  else
+    env.set_signals
+    env.build(ARGV) do |args|
+      warn "warning: implict rake for [#{args.join(' ')}]"
+      Rap::Rake
+    end
+    ARGV.clear
+    
+    app = env.app
+    if app.queue.empty?
+      puts "no task specified"
+      exit
+    end
+    
+    app.run
+  end
+  
+rescue
+  env.handle_error($!)
+end
+
+exit(0)

data/doc/Command Reference

@@ -0,0 +1,22 @@
+= Command Reference
+
+Rap comes the rap executable.  For help on the command line, type:
+
+  % rap --help
+
+The rap executable is basically a shorthand for 'tap run --'.  Specifying tasks
+for rap is no different than 'tap run' (see the Tap {Command Reference}[http://tap.rubyforge.org/rdoc/files/doc/Command%20Reference.html]).
+The only exception occurs when the task can't be found; unknown tasks are run
+as if by rake.  For instance all of these are the same:
+
+Run a rake task with inputs and an ENV config:
+
+  % rake task_name[1,2,3] key=value
+
+Explicitly run a Rap::Rake task using the same inputs:
+
+  % rap rake task_name[1,2,3] key=value
+
+Implicitly run the Rap::Rake task:
+
+  % rap task_name[1,2,3] key=value

data/doc/Syntax Reference

@@ -0,0 +1,82 @@
+= Syntax Reference
+
+== Task Declarations
+
+A task declaration:
+
+  # name::           the name of the task, either alone or as the
+  #                  key of a {key => dependencies} hash
+  # dependencies::   an array of task names (optional)
+  # arg_names::      an array of argument names (optional)
+  # configurations:: a hash of {key => default} pairs (optional)
+
+  task({<name> => [<dependencies...>]}, <arg_names...>, {<configs>}) do |task, args|
+    # arguments are available through args:
+    args.arg_name
+    
+    # configurations are available through task
+    task.key
+  end
+
+A namespace declaration:
+
+  namespace(<name>) { task ... }
+ 
+Simple documentation:
+ 
+  desc "description"
+  task ...
+  
+Extended documentation:
+  
+  # ::desc description
+  # Extended documentation may span multiple lines, and 
+  # supports
+  #
+  #   code indentation
+  #   like this.
+  #
+  # Lines are justified and wrapped on the command line.
+  task ...
+
+Pains were taken to make task declarations for rap work the similar to rake
+tasks.  In both cases (noting that in general, beyond rap, task classes are
+not limited in these ways):
+
+* tasks are singleton instances that may be extended across multiple
+  declarations
+* tasks do not pass inputs from one task to the next
+* tasks only execute once
+
+A few syntactical differences between rake and rap must to be noted, as they
+can cause errors if you try to migrate rake tasks to tap.
+
+==== no needs
+
+Rap does not support :needs as a way to specify dependencies.  For instance,
+this will declare a ':needs' configuration with the default value ':another',
+not a task which depends on another:
+
+  Rap.task :name, :needs => :another
+
+==== immediate namespace lookup
+
+Within a namespace, task will look for a literal match to the dependency first.
+If it doesn't find one, it will declare it within the namespace; one way or the
+other the dependency is resolved to a constant immediately.  Hence, in this
+example the nested task depends on the non-nested task.  
+
+  task :outer { print 'non-nested' }
+  namespace :nest do
+    task :inner => :outer { puts 'was executed' }
+    task :outer { print 'nested' }
+  end
+  
+By contrast, rake waits to resolve dependencies and will always use a match
+within a namespace in preference to a literal match.  For these tasks rap and
+rake produce different results:
+
+  % rap nest/inner
+  non-nested was executed
+  % rake nest:inner
+  nested was executed

data/lib/rap/declaration_task.rb

@@ -0,0 +1,114 @@
+require 'tap'
+require 'ostruct'
+require 'rap/description'
+
+module Rap
+  
+  # DeclarationTasks are a singleton version of tasks.  DeclarationTasks only
+  # have one instance (DeclarationTask.instance) and the instance is
+  # registered as a dependency, so it will only execute once.
+  class DeclarationTask < Tap::Task
+    class << self
+      attr_writer :actions
+      
+      # An array of actions (blocks) associated with this class.  Each of the
+      # actions is called during process, with the instance and any args
+      # passed to process organized into an OpenStruct.
+      def actions
+        @actions ||= []
+      end
+      
+      attr_writer :arg_names
+      
+      # The argument names pulled from a task declaration.
+      def arg_names
+        @arg_names ||= []
+      end
+      
+      # Returns a Lazydoc::Arguments constructed from arg_names.
+      def args
+        args = Lazydoc::Arguments.new
+        arg_names.each {|name| args.arguments << name.to_s }
+        args
+      end
+      
+      # Initializes instance and registers it as a dependency.
+      def new(*args)
+        @instance ||= super
+        @instance.app.dependencies.register(@instance)
+        @instance
+      end
+      
+      # Looks up or creates the DeclarationTask subclass specified by name
+      # (nested within declaration_base), and adds the configs and dependencies.
+      # Declare also registers the subclass in the declaration_env tasks
+      # manifest.
+      # 
+      # Configurations are always validated using the yaml transformation block
+      # (see {Configurable::Validation.yaml}[http://tap.rubyforge.org/configurable/classes/Configurable/Validation.html]).
+      #
+      def subclass(const_name, configs={}, dependencies=[])
+        # lookup or generate the subclass
+        subclass = Tap::Support::Constant.constantize(const_name.to_s) do |base, constants|
+          subclass_const = constants.pop
+          constants.inject(base) do |namespace, const|
+            # nesting Task classes into other Task classes is required
+            # for namespaces with the same name as a task
+            namespace.const_set(const, Class.new(DeclarationTask))
+          end.const_set(subclass_const, Class.new(self))
+        end
+
+        # check a correct class was found
+        unless subclass.ancestors.include?(self)
+          raise "not a #{self}: #{subclass}"
+        end
+
+        # append configuration (note that specifying a desc 
+        # prevents lazydoc registration of these lines)
+        convert_to_yaml = Configurable::Validation.yaml
+        configs.each_pair do |key, value|
+          subclass.send(:config, key, value, :desc => "", &convert_to_yaml)
+        end
+
+        # add dependencies
+        dependencies.each do |dependency|
+          dependency_name = File.basename(dependency.default_name)
+          subclass.send(:depends_on, dependency_name, dependency)
+        end
+        
+        subclass
+      end
+      
+      private
+      
+      # overridden to provide self as the declaration_class
+      def declaration_class # :nodoc:
+        self
+      end
+    end
+    
+    # Collects the inputs into an OpenStruct according to the class arg_names,
+    # and calls each class action in turn.  This behavior echoes the behavior
+    # of Rake tasks.
+    def process(*inputs)
+      # collect inputs to make a rakish-args object
+      args = {}
+      self.class.arg_names.each do |arg_name|
+        break if inputs.empty?
+        args[arg_name] = inputs.shift
+      end
+      args = OpenStruct.new(args)
+      
+      # execute each block assciated with this task
+      self.class.actions.each do |action|
+        case action.arity
+        when 0 then action.call()
+        when 1 then action.call(self)
+        else action.call(self, args)
+        end
+      end
+      
+      nil
+    end
+  end
+end

data/lib/rap/declarations.rb

@@ -0,0 +1,213 @@
+require 'rap/declaration_task'
+require 'tap/support/shell_utils'
+
+module Rap
+  
+  # Defines the rakish task declaration methods.  They may be included at the
+  # top level (like Rake) or, since they included as a part of the API, used
+  # through Rap.
+  #
+  # Unlike rake, task will define actual task classes according to the task
+  # names.  Task classes may be nested within modules using namespace.  It's
+  # VERY important to realize this is the case both to aid in thing like
+  # testing and to prevent namespace conflicts.  For example:
+  #
+  #   Rap.task(:sample)              # => Sample.instance
+  #   Rap.namespace(:nested) do
+  #     Rap.task(:sample)            # => Nested::Sample.instance
+  #   end
+  #
+  # Normally all declared tasks are subclasses of DeclarationTask.  An easy
+  # way to use an existing subclasses of DeclarationTask as a base task is
+  # to call declare on the subclass.  This feature is only available to
+  # subclasses of DeclarationTask, but can be used within namespaces, and in
+  # conjunction with desc.
+  #
+  #   class Alt < DeclarationTask
+  #   end
+  #
+  #   include Rap::Declarations
+  #
+  #   desc "task one, a subclass of DeclarationTask"
+  #   o = Rap.task(:one)
+  #   o.class                          # => One
+  #   o.class.superclass               # => DeclarationTask
+  #   o.class.manifest.desc            # => "task one, a subclass of DeclarationTask"
+  #
+  #   namespace(:nest) do
+  #
+  #     desc "task two, a nested subclass of Alt"
+  #     t = Alt.declare(:two)
+  #     t.class                          # => Nest::Two
+  #     t.class.superclass               # => Alt
+  #     t.class.manifest.desc            # => "task two, a nested subclass of Alt"
+  #   
+  #   end
+  #
+  # See the {Syntax Reference}[link:files/doc/Syntax%20Reference.html] for usage.
+  module Declarations
+    include Tap::Support::ShellUtils
+    
+    # The environment in which declared task classes are registered.
+    # By default the Tap::Env for Dir.pwd.
+    def Declarations.env() @@env ||= Tap::Env.instantiate(Dir.pwd); end
+    
+    # Sets the declaration environment.
+    def Declarations.env=(env) @@env=env; end
+    
+    # The base constant for all task declarations, prepended to the task name.
+    def Declarations.current_namespace() @@current_namespace; end
+    @@current_namespace = ''
+    
+    # Tracks the current description, which will be used to
+    # document the next task declaration.
+    def Declarations.current_desc() @@current_desc; end
+    @@current_desc = nil
+    
+    # Declares a task with a rake-like syntax.  Task generates a subclass of
+    # DeclarationTask, nested within the current namespace.
+    def task(*args, &action)
+      # resolve arguments and declare unknown dependencies
+      name, configs, dependencies, arg_names = resolve_args(args) do |dependency| 
+        register DeclarationTask.subclass(dependency)
+      end
+      
+      # generate the task class
+      const_name = File.join(@@current_namespace, name.to_s).camelize
+      task_class = register declaration_class.subclass(const_name, configs, dependencies)
+      
+      # register documentation        
+      manifest = Lazydoc.register_caller(Description)
+      manifest.desc = @@current_desc
+      @@current_desc = nil
+      
+      task_class.arg_names = arg_names
+      task_class.manifest = manifest
+      task_class.source_file = manifest.document.source_file
+      
+      # add the action
+      task_class.actions << action if action
+      
+      # return the instance
+      task_class.instance
+    end
+    
+    # Nests tasks within the named module for the duration of the block.
+    # Namespaces may be nested.
+    def namespace(name)
+      previous_namespace = @@current_namespace
+      @@current_namespace = File.join(previous_namespace, name.to_s.underscore)
+      yield
+      @@current_namespace = previous_namespace
+    end
+    
+    # Sets the description for use by the next task declaration.
+    def desc(str)
+      @@current_desc = str
+    end
+    
+    private
+    
+    # A helper to resolve the arguments for a task; returns the array
+    # [task_name, configs, needs, arg_names].
+    #
+    # Adapted from Rake 0.8.3
+    # Changes:
+    # - no :needs support for the trailing Hash (which is now config)
+    def resolve_args(args)
+      task_name = args.shift
+      arg_names = args
+      configs = {}
+      needs = []
+
+      # resolve hash task_names, for the syntax:
+      #   task :name => [dependencies]
+      if task_name.is_a?(Hash)
+        hash = task_name
+        case hash.length
+        when 0 
+          task_name = nil
+        when 1 
+          task_name = hash.keys[0]
+          needs = hash[task_name]
+        else
+          raise ArgumentError, "multiple task names specified: #{hash.keys.inspect}"
+        end
+      end
+
+      # ensure a task name is specified
+      if task_name == nil
+        raise ArgumentError, "no task name specified" if args.empty?
+      end
+
+      # pop off configurations, if present, using the syntax:
+      #   task :name, :one, :two, {configs...}
+      if arg_names.last.is_a?(Hash)
+        configs = arg_names.pop
+      end
+
+      needs = needs.respond_to?(:to_ary) ? needs.to_ary : [needs]
+      needs = needs.compact.collect do |need|
+
+        unless need.kind_of?(Class)
+          # lookup or declare non-class dependencies
+          name = normalize_name(need).camelize
+          need = Tap::Support::Constant.constantize(name) do |base, constants|
+            const = block_given? ? yield(name) : nil
+            const or raise ArgumentError, "unknown task class: #{name}"
+          end
+        end
+
+        unless need.ancestors.include?(Tap::Task)
+          raise ArgumentError, "not a task class: #{need}"
+        end
+
+        need
+      end
+
+      [normalize_name(task_name), configs, needs, arg_names]
+    end
+
+    # helper to translate rake-style names to tap-style names, ie
+    #
+    #   normalize_name('nested:name')    # => "nested/name"
+    #   normalize_name(:symbol)          # => "symbol"
+    #
+    def normalize_name(name)
+      name.to_s.tr(":", "/")
+    end
+    
+    # The class of task declared by task, by default DeclarationTask. 
+    # Used as a hook to set the declaring class in including modules 
+    # (such as DeclarationTask itself).
+    def declaration_class
+      DeclarationTask
+    end
+    
+    # Registers a task class with the Declarations.env, if necessary.
+    # Returns task_class.
+    def register(task_class)
+      tasks = Declarations.env.tasks
+      const_name = task_class.to_s
+      unless tasks.entries.any? {|const| const.name == const_name }
+        tasks.entries << Tap::Support::Constant.new(const_name)
+      end
+      
+      task_class
+    end
+  end
+  
+  class DeclarationTask
+    class << self
+      include Declarations
+      
+      # alias task as declare, so that DeclarationTask and subclasses
+      # may directly declare subclasses of themselves
+      
+      alias declare task
+      private :task, :desc, :namespace
+    end
+  end
+  
+  extend Declarations
+end

data/lib/rap/description.rb

@@ -0,0 +1,32 @@
+module Rap
+  
+  # :::-
+  # A special type of Lazydoc::Comment designed to handle the comment syntax
+  # for task declarations.
+  #
+  # Description instances can be assigned a description, or they may parse
+  # one directly from the comment.  Comment lines with the constant attribute
+  # '::desc' will have the value set as desc.
+  # :::+
+  class Description < Lazydoc::Comment
+    
+    # The description for self.
+    attr_accessor :desc
+    
+    # Parses in-comment descriptions from prepended lines, if present.
+    def prepend(line)
+      if line =~ /::desc\s+(.*?)\s*$/
+        self.desc = $1
+        false
+      else
+        super
+      end
+    end
+    
+    # Resolves and returns the description.
+    def to_s
+      resolve
+      desc.to_s
+    end
+  end
+end

data/lib/rap/rake.rb

@@ -0,0 +1,54 @@
+require 'rap/rake_app'
+
+module Rap
+
+  # :startdoc::manifest run rake tasks
+  # 
+  # Simply enques the specified rake task(s) for execution.  Useful when a
+  # rake task needs to be executed within a workflow.  For example these
+  # are equivalent:
+  #
+  #   % tap run -- rake test
+  #   % rake test
+  # 
+  # The only exeception is in the use of the --help option.  Use --rake-help
+  # to access the rake help, and --help to access this help.
+  #
+  class Rake < Tap::Task
+    class << self
+  
+      # Overrides Tap::Support::FrameworkClass#parse! to do  
+      # nothing so that all args get passed forward to rake.
+      def parse!(argv, app=Tap::App.instance) # => instance, argv
+        if argv.include?('--help')
+          puts help
+          exit
+        end
+        [new({}, default_name, app), argv.collect {|arg| arg == '--rake-help' ? '--help' : arg}]
+      end
+    end
+  
+    def enq(*argv)
+      rake = ::Rake.application
+    
+      # run as if from command line using argv
+      current_argv = ARGV.dup
+      begin
+        ARGV.clear
+        ARGV.concat(argv)
+
+        # now follow the same protocol as 
+        # in run, handling options
+        rake.init
+        rake.load_rakefile
+      ensure
+        ARGV.clear
+        ARGV.concat(current_argv)
+      end
+  
+      rake.enq_top_level(app)
+  
+      nil
+    end
+  end
+end

data/lib/rap/rake_app.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'rake'
+require 'tap'
+
+module Rap
+  class RakeManifest < Tap::Support::Manifest
+    def initialize(env)
+      @env = env
+      rake = ::Rake.application
+      super(rake.have_rakefile(env.root.root) ? [rake.instance_variable_get(:@rakefile)] : [])
+    end
+  end
+
+  module RakeApp
+    def self.extended(base)
+      Tap::Env.instantiate(Dir.pwd).activate unless Tap::Env.instance
+      base.env = Tap::Env.instance
+    end
+  
+    attr_accessor :env
+   
+    def enq_top_level(app)
+      # takes the place of rake.top_level
+      if options.show_tasks
+        display_tasks_and_comments
+        exit
+      elsif options.show_prereqs
+        display_prerequisites
+        exit
+      else
+        top_level_tasks.each do |task_string|
+          name, args = parse_task_string(task_string)
+          task = self[name]
+          app.mq(task, :invoke, *args)
+        end
+      end  
+    end
+    
+    def collect_tasks(*args)
+      # a little song and dance for compliance with
+      # rake pre- and post-0.8.2
+      argv = args.empty? ? ARGV : args[0]
+      argv.collect! do |arg|
+        next(arg) unless arg =~ /^:([a-z_\d]+):(.*)$/
+        env_pattern = $1
+        rake_task = $2
+      
+        next(arg) unless entry = env.find(:envs, env_pattern, false)
+      
+        mini_path, env = entry
+        root_path = env.root.root
+      
+        if have_rakefile(root_path)
+          # load sequence echos that in raw_load_rakefile
+          puts "(in #{root_path})" unless options.silent
+          current_global_rakefile = $rakefile
+          $rakefile = @rakefile
+        
+          namespaces = Tap::Root.split(mini_path, false).delete_if do |segment| 
+            segment.empty?
+          end
+        
+          #if @rakefile != ''
+          eval nest_namespace(%Q{load "#{File.join(root_path, @rakefile)}"}, namespaces.dup)
+          #end
+        
+          $rakefile = current_global_rakefile
+          @rakefile = nil
+        
+          namespaces << rake_task
+          namespaces.join(":")
+        else
+          fail "No Rakefile found for '#{env_pattern}' (looking for: #{@rakefiles.join(', ')})"
+        end
+      end
+      
+      super
+    end
+  
+    def have_rakefile(dir=nil)
+      return super() if dir == nil
+      Tap::Root.chdir(dir) { super() }
+    end
+
+    protected
+  
+    NAMESPACE_STR = %Q{
+namespace(:'%s') do
+%s
+end
+}.strip
+  
+    def nest_namespace(nest_str, namespaces)
+      return nest_str if namespaces.empty?
+    
+      NAMESPACE_STR % [
+        namespaces.shift, 
+        namespaces.empty? ? nest_str : nest_namespace(nest_str, namespaces)
+      ]
+    end
+  end
+end
+
+Rake.application.extend Rap::RakeApp
+Tap::Env.manifest(:rakefiles) do |env|
+  Rap::RakeManifest.new(env)
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: rap
+version: !ruby/object:Gem::Version 
+  version: 0.12.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-17 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.0
+    version: 
+description: 
+email: simon.a.chiang@gmail.com
+executables: 
+- rap
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+- History
+- doc/Command Reference
+- doc/Syntax Reference
+files: 
+- lib/rap/declaration_task.rb
+- lib/rap/declarations.rb
+- lib/rap/description.rb
+- lib/rap/rake_app.rb
+- lib/rap/rake.rb
+- tap.yml
+- README
+- MIT-LICENSE
+- History
+- doc/Command Reference
+- doc/Syntax Reference
+has_rdoc: true
+homepage: http://tap.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- -S
+- -N
+- --title
+- Rap (Rakish App)
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: tap
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A rakish extension to tap.
+test_files: []
+