bahuvrihi-tap 0.10.7 → 0.10.8

data/lib/tap.rb

@@ -1,11 +1,5 @@
 autoload(:YAML, 'yaml')                   # expensive to load
 
-# Apply version-specific patches
-case RUBY_VERSION
-when /^1.9/
-  $: << File.expand_path(File.dirname(__FILE__) + "/tap/patches/ruby19")
-end
-
 $:.unshift File.expand_path(File.dirname(__FILE__))
 
 require 'tap/constants'
@@ -13,9 +7,4 @@ require 'tap/constants'
 # require in order...
 require 'tap/exe'
 require 'tap/task'
-require 'tap/file_task'
-
-# Apply platform-specific patches
-# case RUBY_PLATFORM
-# when 'java' 
-# end
+require 'tap/file_task'

data/lib/tap/app.rb

@@ -4,9 +4,6 @@ require 'tap/support/dependencies'
 require 'tap/support/executable_queue'
 
 module Tap
-  module Support
-    autoload(:Combinator, 'tap/support/combinator')
-  end
   
   # App coordinates the setup and running of tasks, and provides an interface 
   # to the application directory structure.  App is convenient for use within 
@@ -19,23 +16,22 @@ module Tap
   # access application-wide resources like the logger.  Additionally, task
   # enque command are forwarded to App#enq:
   #
-  #   t1 = Task.new {|task, input| input += 1 }
+  #   t1 = Task.intern {|task, input| input += 1 }
   #   t1.enq(0)
   #   app.enq(t1, 1)
   #
   #   app.run
   #   app.results(t1)                # => [1, 2]
   #
-  # When a task completes, the results will either be passed to the task
-  # <tt>on_complete</tt> block (if set) or be collected into an Aggregator;
-  # aggregated results may be accessed per-task, as shown above.  Task 
-  # <tt>on_complete</tt> blocks typically enque other tasks, allowing the
-  # construction of imperative workflows:
+  # When a task completes, the results will be passed to the task on_complete
+  # block, if set, or be collected into an Aggregator (aggregated results may 
+  # be accessed per-task, as shown above); on_complete blocks typically enque
+  # other tasks, allowing the construction of imperative workflows:
   #
   #   # clear the previous results
   #   app.aggregator.clear
   #
-  #   t2 = Task.new {|task, input| input += 10 }
+  #   t2 = Task.intern {|task, input| input += 10 }
   #   t1.on_complete {|_result| t2.enq(_result) }
   #
   #   t1.enq 0
@@ -52,32 +48,31 @@ module Tap
   #
   # Tasks allow the construction of dependency-based workflows as well; tasks
   # may be set to depend on other tasks such that the dependent task only 
-  # executes after the dependencies have been resolved (ie executed with a
-  # given set of inputs).
+  # executes after the dependencies have been resolved.
   #
   #   array = []
-  #   t1 = Task.new {|task, *inputs| array << inputs }
-  #   t2 = Task.new {|task, *inputs| array << inputs }
+  #   t1 = Task.intern {|task, *inputs| array << inputs }
+  #   t2 = Task.intern {|task| array << self }
   #
-  #   t1.depends_on(t2,1,2,3)
+  #   t1.depends_on(t2)
   #   t1.enq(4,5,6)
   #
   #   app.run
-  #   array                          # => [[1,2,3], [4,5,6]]
+  #   array                          # => [t2, [4,5,6]]
   #
   # Once a dependency is resolved, it will not execute again:
   #
   #   t1.enq(7,8)
   #   app.run
-  #   array                          # => [[1,2,3], [4,5,6], [7,8]]
+  #   array                          # => [t2, [4,5,6], [7,8]]
   #
   # ==== Batching
   #
   # Tasks can be batched, allowing the same input to be enqued to multiple 
   # tasks at once.
   #
-  #   t1 = Task.new  {|task, input| input += 1 }
-  #   t2 = Task.new  {|task, input| input += 10 }
+  #   t1 = Task.intern  {|task, input| input += 1 }
+  #   t2 = Task.intern  {|task, input| input += 10 }
   #
   #   t1.batch_with(t2)
   #   t1.enq 0
@@ -88,11 +83,8 @@ module Tap
   #
   # ==== Executables
   #
-  # App can use any Executable object in place of a task. One way to initialize 
-  # an Executable for a method is to use the Object#_method defined by Tap.  The 
-  # result can be enqued and incorporated into workflows, but they cannot be 
-  # batched.
-  #
+  # App can enque and run any Executable object. One way to initialize an
+  # Executable for a method is to use the Object#_method added by Tap.
   # The mq (method enq) method generates and enques the method in one step.
   #
   #   array = []
@@ -107,17 +99,15 @@ module Tap
   #
   # === Auditing
   # 
-  # All results generated by executable methods are audited to track how a given  
-  # input evolves during a workflow.   
-  #
+  # All results are audited to track how a given input evolves during a workflow.
   # To illustrate auditing, consider a workflow that uses the 'add_one' method 
   # to add one to an input until the result is 3, then adds five more with the 
   # 'add_five' method.  The final result should always be 8.  
   #
-  #   t1 = Tap::Task.new {|task, input| input += 1 }
+  #   t1 = Tap::Task.intern {|task, input| input += 1 }
   #   t1.name = "add_one"
   #
-  #   t2 = Tap::Task.new {|task, input| input += 5 }
+  #   t2 = Tap::Task.intern {|task, input| input += 5 }
   #   t2.name = "add_five"
   #
   #   t1.on_complete do |_result|
@@ -189,9 +179,10 @@ module Tap
     attr_reader :state
     
     # A Tap::Support::Aggregator to collect the results of 
-    # methods that have no <tt>on_complete</tt> block
+    # methods that have no on_complete block
     attr_reader :aggregator
     
+    # A Tap::Support::Dependencies to track dependencies.
     attr_reader :dependencies
     
     config :debug, false, &c.flag                 # Flag debugging
@@ -270,36 +261,37 @@ module Tap
     # Execution methods
     #
     
-    # Executes the input Executable with the inputs.  Stores the result in 
-    # aggregator unless an on_complete block is set.  Returns the audited 
-    # result.
-    def execute(m, inputs)
-      m._execute(*inputs)
-    end
-
     # Sets state = State::READY unless the app is running.  Returns self.
     def ready
-      self.state = State::READY unless self.state == State::RUN
+      @state = State::READY unless state == State::RUN
       self
     end
 
-    # Sequentially calls execute with the Executable methods and inputs in 
-    # queue; run continues until the queue is empty and then returns self. 
-    # Calls to run when already running will return immediately.
+    # Sequentially calls execute with the [executable, inputs] pairs in
+    # queue; run continues until the queue is empty and then returns self.
+    #
+    # ==== Run State
     #
-    # Run checks the state of self before executing a method.  If the state is 
-    # changed to State::STOP, then no more methods will be executed; currently 
-    # running methods will continute to completion.  If the state is changed to 
-    # State::TERMINATE then no more methods will be executed and currently 
-    # running methods will be discontinued as described in terminate.
+    # Run checks the state of self before executing a method. If state
+    # changes from State::RUN, the following behaviors result:
+    # 
+    # State::STOP:: No more executables will be executed; the current
+    #               executable will continute to completion.
+    # State::TERMINATE:: No more executables will be executed and the
+    #                    currently running executable will be
+    #                    discontinued as described in terminate.
+    #
+    # Calls to run when the state is not State::READY do nothing and
+    # return immediately.
     def run
       return self unless state == State::READY
-      self.state = State::RUN
+      @state = State::RUN
 
       # TODO: log starting run
       begin
         until queue.empty? || state != State::RUN
-          execute(*queue.deq)
+          executable, inputs = queue.deq
+          executable._execute(*inputs)
         end
       rescue(TerminateError)
         # gracefully fail for termination errors
@@ -308,7 +300,7 @@ module Tap
         raise if debug?
         log($!.class, $!.message)
       ensure
-        self.state = State::READY
+        @state = State::READY
       end
       
       # TODO: log run complete
@@ -321,7 +313,7 @@ module Tap
     #
     # Does nothing unless state is State::RUN.
     def stop
-      self.state = State::STOP if self.state == State::RUN
+      @state = State::STOP if state == State::RUN
       self
     end
 
@@ -329,11 +321,11 @@ module Tap
     # state = State::TERMINATE.  In this state, an executing task 
     # will then raise a TerminateError upon check_terminate, thus 
     # allowing the invocation of task-specific termination, perhaps 
-    # performing rollbacks. (see Tap::Task#check_terminate).
+    # performing rollbacks. (see Tap::Support::Executable#check_terminate).
     #
     # Does nothing if state == State::READY.
     def terminate
-      self.state = State::TERMINATE unless self.state == State::READY
+      @state = State::TERMINATE unless state == State::READY
       self
     end
     
@@ -341,11 +333,6 @@ module Tap
     #
     #   App.instance.info   # => 'state: 0 (READY) queue: 0 results: 0'
     #
-    # Provided information:
-    #
-    # state:: the integer and string values of self.state
-    # queue:: the number of methods currently in the queue
-    # results:: the total number of results in aggregator
     def info
       "state: #{state} (#{State.state_str(state)}) queue: #{queue.size} results: #{aggregator.size}"
     end
@@ -384,8 +371,8 @@ module Tap
     # Returns all aggregated results for the specified tasks.  Results are
     # joined into a single array.  Arrays of tasks are allowed as inputs.    
     #
-    #   t1 = Task.new  {|task, input| input += 1 }
-    #   t2 = Task.new  {|task, input| input += 10 }
+    #   t1 = Task.intern  {|task, input| input += 1 }
+    #   t2 = Task.intern  {|task, input| input += 10 }
     #   t3 = t2.initialize_batch_obj
     #
     #   t1.enq(0)
@@ -403,18 +390,6 @@ module Tap
       "#<#{self.class.to_s}:#{object_id} root: #{root} >"
     end
     
-    protected
-    
-    # A hook for handling unknown configurations in subclasses, called from
-    # configure.  If handle_configuration evaluates to false, then configure
-    # raises an error.
-    def handle_configuation(key, value)
-      false
-    end
-    
-    # Sets the state of the application
-    attr_writer :state
-
     # TerminateErrors are raised to kill executing tasks when terminate is 
     # called on an running App.  They are handled by the run rescue code.
     class TerminateError < RuntimeError 

data/lib/tap/constants.rb

@@ -1,7 +1,7 @@
 module Tap
   MAJOR = 0
   MINOR = 10
-  TINY = 7
+  TINY = 8
   
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}" 
   WEBSITE="http://tap.rubyforge.org"

data/lib/tap/declarations.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../tap"
+require File.dirname(__FILE__) + "/../tap"
 autoload(:OpenStruct, 'ostruct')
 
 module Tap
@@ -22,39 +22,49 @@ module Tap
       end
     end
     
-    def self.set_declaration_base(base)
-      # TODO -- warn if base is Object -- conflict with Rake
-      declaration_base = base.to_s
-      declaration_base = "" if ["Object", "Tap"].include?(declaration_base)
-
-      base.instance_variable_set(:@tap_declaration_base, declaration_base.underscore)
-    end
-
-    def self.included(base)
-      set_declaration_base(base)
+    module Rakish
+      def new(*args)
+        @instance ||= super
+        @instance.app.dependencies.register(@instance)
+        @instance
+      end
     end
-
+    
     def self.extended(base)
-      set_declaration_base(base)
+      declaration_base = base.to_s
+      case declaration_base
+      when "Object", "Tap", "main"
+        declaration_base = ""
+      end
+      
+      base.instance_variable_set(:@declaration_base, declaration_base.underscore)
+      base.instance_variable_set(:@current_desc, nil)
+    end
+    
+    def self.env
+      @env ||= Tap::Env.new(:load_paths => [], :command_paths => [], :generator_paths => [])
     end
     
-    def tasc(*args, &block)
-      # in this scheme, arg_names will be empty
-      name, configs, dependencies, arg_names = resolve_args(args)
-      declare(Tap::Task, name, configs, dependencies, arg_names, &block)
+    def env
+      @env ||= Declarations.env
     end
     
+    attr_accessor :declaration_base
+    
+    attr_accessor :current_desc
+    
     def task(*args, &block)
-      name, configs, dependencies, arg_names = resolve_args(args)
-      
-      task_class = declare(Tap::Task, name, configs, dependencies, arg_names) do |*inputs|
+      const_name, configs, dependencies, arg_names = resolve_args(args)
+      task_class = declare(const_name, configs, dependencies) do |*inputs|
+        # collect inputs to make a rakish-args object
         args = {}
         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::BLOCKS.each do |task_block|
           case task_block.arity
           when 0 then task_block.call()
@@ -62,46 +72,37 @@ module Tap
           else task_block.call(self, args)
           end
         end
+        
+        nil
       end
+      register_doc(task_class, arg_names)
       
+      # add the block to the task
       unless task_class.const_defined?(:BLOCKS)
         task_class.const_set(:BLOCKS, [])
       end
       task_class::BLOCKS << block unless block == nil
-      
       task_class.instance
     end
     
-    protected
-
-    def config(key, value=nil, options={}, &block)
-      if options[:desc] == nil
-        caller[0] =~ Lazydoc::CALLER_REGEXP
-        options[:desc] = Lazydoc.register($1, $3.to_i - 1)
-      end 
-
-      [:config, key, value, options, block]
+    def namespace(name, &block)
+      current_base = declaration_base
+      @declaration_base = File.join(current_base, name.to_s.underscore)
+      yield
+      @declaration_base = current_base
     end
-
-    def config_attr(key, value=nil, options={}, &block)
-      if options[:desc] == nil
-        caller[0] =~ Lazydoc::CALLER_REGEXP
-        options[:desc] = Lazydoc.register($1, $3.to_i - 1)
-      end
-
-      [:config_attr, key, value, options, block]
-    end
-
-    def c
-      Tap::Support::Validation
+    
+    def desc(str)
+      self.current_desc = Lazydoc::Comment.new
+      current_desc.subject = str
     end
-
-    private
     
-    # Resolve the arguments for a task/rule.  Returns a triplet of
-    # [task_name, configs, prerequisites, arg_name_list].
+    protected
+    
+    # Resolve the arguments for a task/rule.  Returns an array of
+    # [task_name, configs, needs, arg_names].
     #
-    # From Rake 0.8.3
+    # Adapted from Rake 0.8.3
     # Changes:
     # - no :needs support for the trailing Hash (which is now config)
     def resolve_args(args)
@@ -122,79 +123,88 @@ module Tap
       
       needs = needs.respond_to?(:to_ary) ? needs.to_ary : [needs]
       needs = needs.compact.collect do |need|
-        dependency, argv = case need
-        when Array then need
-        else [need, []]
-        end
-        
-        unless dependency.kind_of?(Class)
-          dependency = declare(Tap::Task, dependency)
+        unless need.kind_of?(Class)
+          name = normalize_name(need).camelize
+          need = Support::Constant.constantize(name) do |base, constants|
+            declare(name)
+          end
         end
   
-        if dependency.ancestors.include?(Tap::Task)
-          [File.basename(dependency.default_name), dependency, argv]
-        else
-          raise ArgumentError, "malformed dependency declaration: #{need}"
+        unless need.ancestors.include?(Tap::Task)
+          raise ArgumentError, "not a task: #{need}"
         end
+        
+        need
       end
       
-      [task_name, configs, needs, arg_names]
+      [normalize_name(task_name), configs, needs, arg_names]
     end
-
-    def arity(block)
-      arity = block.arity
-      
-      case
-      when arity > 0 then arity -= 1
-      when arity < 0 then arity += 1
-      end
-      
-      arity
+    
+    def normalize_name(name)
+      name.to_s.underscore.tr(":", "/")
     end
     
-    def declare(klass, name, configs={}, dependencies=[], arg_names=[], &block)
-      # nest the constant name
-      base = (self.kind_of?(Module) ? self : self.class).instance_variable_get(:@tap_declaration_base)
-      name = File.join(base, name.to_s)
+    def declare(name, configs={}, dependencies=[], &block)
+      const_name = File.join(declaration_base, name).camelize
       
       # generate the subclass
-      subclass = klass.subclass(name, configs, dependencies, &block)
-      
-      # register documentation
-      caller[1] =~ Lazydoc::CALLER_REGEXP
-      subclass.source_file = File.expand_path($1)
-      lazydoc = subclass.lazydoc(false)
-      lazydoc[subclass.to_s]['manifest'] = lazydoc.register($3.to_i - 1, Lazydoc::Declaration)
-
-      if arg_names.empty?
-        arity = block_given? ? arity(block) : -1
-        case 
-        when arity > 0
-          arg_names = Array.new(arity, "INPUT")
-        when arity < 0
-          arg_names = Array.new(-1 * arity - 1, "INPUT")
-          arg_names << "INPUTS..."
+      subclass = Support::Constant.constantize(const_name) do |base, constants|
+        constants.each do |const|
+          # nesting Tasks into Tasks is required for
+          # namespaces with the same name as a task
+          base = base.const_set(const, Class.new(Tap::Task))
         end
+        base
+      end
+
+      subclass.extend Rakish
+      
+      configs.each_pair do |key, value|
+        subclass.send(:config, key, value)
+      end
+      
+      dependencies.each do |dependency|
+        dependency_name = File.basename(dependency.default_name)
+        subclass.send(:depends_on, dependency_name, dependency)
       end
       
-      comment = Lazydoc::Comment.new
-      comment.subject = arg_names.join(' ')
-      lazydoc[subclass.to_s]['args'] = comment
+      if block_given?
+        subclass.send(:undef_method, :process) if subclass.method_defined?(:process)
+        subclass.send(:define_method, :process, &block)
+      end
       
       # update any dependencies in instance
-      subclass.dependencies.each do |dependency, args|
-        subclass.instance.depends_on(dependency.instance, *args)
+      subclass.dependencies.each do |dependency|
+        subclass.instance.depends_on(dependency.instance)
       end
       
-      dir = File.dirname(lazydoc.source_file)
-      manifest = Tap::Env.instance_for(dir).manifest(:tasks).build
+      # register the subclass in the manifest
+      manifest = env.tasks
       const_name = subclass.to_s
-      unless manifest.entries.find {|lookup, const| const.name == const_name }
-        manifest.entries << [const_name.underscore, Tap::Support::Constant.new(const_name, lazydoc.source_file)]
+      unless manifest.find {|const| const.name == const_name }
+        manifest.entries << Tap::Support::Constant.new(const_name)
       end
-      
+
       subclass
     end
+    
+    def register_doc(task_class, arg_names)
+      
+      # register documentation
+      caller[1] =~ Lazydoc::CALLER_REGEXP
+      task_class.source_file = File.expand_path($1)
+      lazydoc = task_class.lazydoc(false)
+      lazydoc[task_class.to_s]['manifest'] = current_desc || lazydoc.register($3.to_i - 1, Lazydoc::Declaration)
+      
+      if arg_names
+        comment = Lazydoc::Comment.new
+        comment.subject = arg_names.join(' ')
+        lazydoc[task_class.to_s]['args'] = comment
+      end
+      
+      self.current_desc = nil
+      task_class
+    end
   end
   
   extend Declarations