bahuvrihi-tap 0.10.3 → 0.10.4

data/lib/tap/support/combinator.rb

@@ -0,0 +1,73 @@
+module Tap
+  module Support
+    class Combinator
+      attr_reader :a, :b
+
+      def initialize(*sets)
+        @a = make_set(sets.shift)
+        @b = make_set(*sets)
+      end
+
+      def sets
+        sets_in(@a) + sets_in(@b)
+      end
+
+      def empty?
+        @a.empty? && @b.empty?
+      end
+
+      def length
+        case
+        when !(@a.empty? || @b.empty?)
+          @a.length * @b.length
+        when @a.empty? 
+          @b.length
+        when @b.empty?
+          @a.length
+        end
+      end
+
+      def each
+        case
+        when !(@a.empty? || @b.empty?)
+          @a.each do |*a|
+            @b.each do |*b|
+              yield(*(a + b))
+            end
+          end
+        when @a.empty? 
+          @b.each {|*b| yield(*b) }
+        when @b.empty? 
+          @a.each {|*a| yield(*a) }
+        end
+      end
+
+      def collect
+        cc = []
+        each do |*c| 
+          cc << (block_given? ? yield(*c) : c)
+        end 
+        cc
+      end
+
+      protected
+
+      def sets_in(set)
+        set.kind_of?(Array) ? (set.empty? ? [] : [set]) : set.sets
+      end
+
+      def make_set(*sets)
+        return Combinator.new(*sets) if sets.length > 1 
+        return [] if sets.empty?
+
+        set = sets.first
+        case set 
+        when Combinator then set
+        when Array then set
+        when nil then []
+        else [set]
+        end
+      end
+    end
+  end
+end

data/lib/tap/support/declarations.rb

@@ -78,20 +78,24 @@ module Tap
         end
         
         unless dependencies.kind_of?(Array)
-          dependencies = [dependencies]
+          raise ArgumentError, "dependencies should be specified as an array (was #{dependencies.class})"
         end
         
         unless dependencies.empty?
-          dependencies.collect! do |dependency|
-            case dependency
-            when Array then dependency
-            when String, Symbol then [dependency, declare(Tap::Task, dependency)]
-            else 
-              if dependency.kind_of?(Class) && dependency.ancestors.include?(Tap::Task)
-                [File.basename(dependency.default_name), dependency]
-              else
-                raise ArgumentError, "malformed dependency declaration: #{dependency}"
-              end
+          dependencies.collect! do |entry|
+            dependency, argv = case entry
+            when Array then entry
+            else [entry, []]
+            end
+            
+            unless dependency.kind_of?(Class)
+              dependency = declare(Tap::Task, dependency)
+            end
+      
+            if dependency.ancestors.include?(Tap::Task)
+              [File.basename(dependency.default_name), dependency, argv]
+            else
+              raise ArgumentError, "malformed dependency declaration: #{dependency}"
             end
           end
         end

data/lib/tap/support/dependable.rb

@@ -0,0 +1,73 @@
+module Tap
+  module Support
+    
+    # Dependable encapsulates the module-level methods facilitating 
+    # dependencies in Executable.
+    module Dependable
+      def self.extended(base)
+        base.clear_dependencies
+      end
+      
+      # An array of registered [instance, argv] pairs.
+      attr_reader :registry
+      
+      # An array of results matching the registry, produced 
+      # during dependency resolution by instance._execute(*argv).
+      attr_reader :results
+      
+      # Clears all registered dependencies and results.  
+      def clear_dependencies
+        @registry = []
+        @results = []
+      end
+      
+      # Returns the index of the [instance, argv] pair in self,
+      # or nil if the pair is not registered,
+      def index(instance, argv=[])
+        registry.each_with_index do |entry, index|
+          return index if entry[0] == instance && entry[1] == argv
+        end
+        nil
+      end
+      
+      # Registers an [instance, argv] pair with self and returns the index of 
+      # the pair in the registry; returns the index of a matching pair in the 
+      # registry if the instance and argv are already registered.
+      def register(instance, argv=[])
+        if existing = index(instance, argv)
+          return existing 
+        end
+
+        registry << [instance, argv]
+        registry.length - 1
+      end
+      
+      # Resolves the instance-argv pairs at the specified indicies by calling 
+      # instance._execute(*argv).  Results are collected in results; a pair is 
+      # only resolved if an existing result does not exist.  Returns self.
+      def resolve(indicies)
+        indicies.each do |index|
+          next if results[index]
+          instance, inputs = registry[index]
+          results[index] = instance._execute(*inputs)
+        end
+        self
+      end
+      
+      # Returns true if the results at the specified index are non-nil (note 
+      # that Dependable expects instance-argv pairs to resolve to an Audit; 
+      # the current value of the Audit may, of course, be nil).
+      def resolved?(index)
+        results[index] != nil
+      end
+      
+      # Sets the results at specified indicies to nil so that their 
+      # instance-argv pairs will re-execute on resolve. Returns self.
+      def reset(indicies)
+        indicies.each {|index| results[index] = nil }
+        self
+      end
+      
+    end
+  end
+end

data/lib/tap/support/executable.rb

@@ -1,4 +1,5 @@
 require 'tap/support/audit'
+require 'tap/support/dependable'
 
 module Tap
   module Support
@@ -7,77 +8,28 @@ module Tap
     # wrapped by extending the object that receives them; the easiest way
     # to make an object executable is to use Object#_method.
     module Executable
+      extend Dependable
       
       # The method called when an Executable is executed via _execute
       attr_reader :_method_name
     
-      # Indicates whether or not to execute in multithread mode.
-      attr_accessor :multithread
-
-      # Stores the on complete block.
+      # Stores the on complete block
       attr_reader :on_complete_block
       
+      # An array of dependency indexes that will be resolved on _execute
       attr_reader :dependencies
       
       public
       
       # Extends obj with Executable and sets up all required variables.  The
       # specified method will be called on _execute.
-      def self.initialize(obj, method_name, multithread=false, &on_complete_block)
+      def self.initialize(obj, method_name, &on_complete_block)
         obj.extend Executable
         obj.instance_variable_set(:@_method_name, method_name)
-        obj.instance_variable_set(:@multithread, multithread)
         obj.instance_variable_set(:@on_complete_block, on_complete_block)
         obj.instance_variable_set(:@dependencies, [])
         obj
       end
-
-      def self.clear_dependencies
-        @registry = []
-        @results = []
-      end
-      
-      def self.registry
-        @registry
-      end
-      
-      def self.results
-        @results
-      end
-      
-      def self.index(instance, args)
-        @registry.each_with_index do |entry, index|
-          return index if entry[0] == instance && entry[1] == args
-        end
-        nil
-      end
-      
-      def self.resolved?(index)
-        @results[index] != nil
-      end
-      
-      def self.resolve(indicies)
-        indicies.each do |index|
-          next if @results[index]
-          instance, inputs = @registry[index]
-          @results[index] = instance._execute(*inputs)
-        end
-      end
-
-      def self.reset(indicies)
-        indicies.each {|index| @results[index] = nil }
-      end
-      
-      def self.register(instance, args)
-        if existing = index(instance, args)
-          return existing 
-        end
-        
-        @registry << [instance, args]
-        @registry.length - 1
-      end
-      
-      clear_dependencies
       
       # Sets a block to receive the results of _execute.  Raises an error 
       # if an on_complete block is already set.  Override an existing
@@ -93,8 +45,8 @@ module Tap
       end
       
       # Adds the dependency to self, making self dependent on the dependency.
-      # The dependency will be called with the input arguments during 
-      # resolve_dependencies.
+      # The dependency will be resolved by calling dependency._execute with 
+      # the input arguments during resolve_dependencies.
       def depends_on(dependency, *inputs)
         raise ArgumentError, "not an Executable: #{dependency}" unless dependency.kind_of?(Executable)
         raise ArgumentError, "cannot depend on self" if dependency == self
@@ -104,13 +56,15 @@ module Tap
         index
       end
       
-      # Resolves dependencies by calling dependency.resolve with
-      # the dependency arguments.
+      # Resolves dependencies by calling dependency._execute with
+      # the dependency arguments.  (See Dependable#resolve).
       def resolve_dependencies
         Executable.resolve(dependencies)
         self
       end
       
+      # Resets dependencies so they will be re-resolved on resolve_dependencies.
+      # (See Dependable#reset).
       def reset_dependencies
         Executable.reset(dependencies)
         self
@@ -171,7 +125,7 @@ end
 #   push_to_array = array._method(:push)
 #
 #   task = Tap::Task.new  
-#   task.app.sequence(task, push_to_array)
+#   task.sequence(push_to_array)
 #
 #   task.enq(1).enq(2,3)
 #   task.app.run
@@ -181,10 +135,10 @@ end
 class Object
   
   # Initializes a Tap::Support::Executable using the Method returned by
-  # Object#method(method_name), setting multithread and the on_complete 
-  # block as specified.  Returns nil if Object#method returns nil.
-  def _method(method_name, multithread=false, &on_complete_block) # :yields:  _result
+  # Object#method(method_name), setting the on_complete block as specified.  
+  # Returns nil if Object#method returns nil.
+  def _method(method_name, &on_complete_block) # :yields:  _result
     return nil unless m = method(method_name)
-    Tap::Support::Executable.initialize(m, :call, multithread, &on_complete_block)
+    Tap::Support::Executable.initialize(m, :call, &on_complete_block)
   end
 end

data/lib/tap/support/gems/rack.rb

@@ -5,18 +5,6 @@ module Tap
   module Support
     module Gems
       
-      Tap::Env.manifest(:public_paths, "public") do |search_path|
-        Dir.glob(File.join(search_path, "**/*")).collect do |path|
-          ["/" + Tap::Root.relative_filepath(search_path, path), path]
-        end
-      end
-      
-      Tap::Env.manifest(:templates, "template") do |search_path|
-        Dir.glob(File.join(search_path, "**/*.erb")).collect do |path|
-          ["/" + Tap::Root.relative_filepath(search_path, path), path]
-        end
-      end
-      
       Tap::Env.manifest(:cgis, "cgi") do |search_path|
         Dir.glob(File.join(search_path, "**/*.rb")).collect do |path|
           ["/" + Tap::Root.relative_filepath(search_path, path), path]
@@ -28,10 +16,10 @@ module Tap
           path = env['PATH_INFO']
           
           case 
-          when public_page = search(:public_paths, path)
+          when public_page = known_path(:public, path)
             # serve named static pages
             response(env) { File.read(public_page) }
-
+            
           when cgi_page = search(:cgis, path)
             # serve cgis relative to a cgi path
             run_cgi(cgi_page, env)
@@ -45,21 +33,41 @@ module Tap
             end
             template_response('index', env)
             
+          when config[:development] && template_page = known_path(:template, path)
+            response(env) { template(File.read(template_page), env) }
+            
           else
             # handle all other requests as errors
             template_response('404', env)
             
           end
         end
+        
+        def known_path(dir, path)
+          each do |env|
+            directory = env.root.filepath(dir)
+            file = env.root.filepath(dir, path)
+            
+            if file != directory && file.index(directory) == 0 && File.exists?(file)
+              return file
+            end
+          end
+          
+          nil
+        end
 
         #--
         # Runs a cgi and returns an array as demanded by rack.
         def run_cgi(cgi_path, env)
-          current_output = $>
+          current_input = $stdin
+          current_output = $stdout
+          
+          cgi_input = env['rack.input']
           cgi_output = StringIO.new("")
 
           begin
-            $> = cgi_output
+            $stdin = cgi_input
+            $stdout = cgi_output
 
             with_env(env) { load(cgi_path) }
 
@@ -80,7 +88,8 @@ module Tap
             # when an error occurs, return a standard cgi error with backtrace
             [500, {'Content-Type' => 'text/plain'}, %Q{#{$!.class}: #{$!.message}\n#{$!.backtrace.join("\n")}}]
           ensure
-            $> = current_output
+            $stdin = current_input
+            $stdout = current_output
           end
         end
 
@@ -92,7 +101,7 @@ module Tap
           begin
             ENV.clear
             env.each_pair {|key, value| ENV[key] = value if value.kind_of?(String)}
-
+             
             yield
           ensure
             ENV.clear
@@ -123,6 +132,11 @@ module Tap
             end
           end
         end
+        
+        def cgi_template(name, attributes={})
+          path = root.filepath(:template, "#{name}.erb")
+          Templater.new( File.read(path), {:server => self}.merge(attributes) ).build
+        end
 
         def template(template, env, attributes={})
           # partition and sort the env variables into
@@ -142,7 +156,7 @@ module Tap
         end
         
         def template_response(name, env)
-          path = search(:templates, name)
+          path = known_path(:template, "#{name}.erb")
           response(env) { template(File.read(path), env) }
         end
       end

data/lib/tap/support/parsers/server.rb

@@ -5,7 +5,7 @@ module Tap
     module Parsers
       
       # rounds syntax
-      # 0[task]=dump&0[config][key]=value&0[input][]=a&0[input][]=b
+      # 0[tasc]=dump&0[config][key]=value&0[input][]=a&0[input][]=b&0[selected]
       # sequence[1]=1,2,3
       # fork[1]=2,3
       # round[0]=1,2,3
@@ -15,13 +15,13 @@ module Tap
         
         class << self
           def parse_argv(hash)
-            raise ArgumentError, "no task specified" unless hash.has_key?('task')
-            
+            raise ArgumentError, "no task specified" unless hash.has_key?('tasc')
+
             # parse task
-            argv = [hash['task']]
+            argv = [hash.delete('tasc')]
             
             # parse configs
-            configs = hash['config']
+            configs = hash.delete('config')
             configs = YAML.load(configs) if configs.kind_of?(String)
             
             case configs
@@ -35,7 +35,7 @@ module Tap
             end
             
             # parse inputs
-            inputs = hash['inputs']
+            inputs = hash.delete('inputs')
             inputs = YAML.load(inputs) if inputs.kind_of?(String)
             
             case inputs
@@ -49,25 +49,55 @@ module Tap
           
           def parse_pairs(values)
             [*values].collect do |value|
-              value.split(',').collect {|i| i.to_i }
+              case value
+              when String then value.split(',').collect {|i| i.to_i }
+              when Array then value
+              else raise ArgumentError, "non-array inputs specified: #{value}"
+              end
             end.collect do |split|
               next if split.empty?
               [split.shift, split]
             end.compact
           end
+          
+          def compact(argh)
+            compact = {}
+            argh.each_pair do |key, value|
+              compact[key] = case value
+              when Array
+                value.length == 1 && value[0].kind_of?(String) ? value[0] : value
+              when Hash
+                compact(value)
+              else
+                value
+              end
+            end
+            compact
+          end
         end
         
         INDEX = /\A\d+\z/
         
+        attr_reader :attributes
+        
         def initialize(argh)
           @argvs = []
+          @attributes = []
           
           argh.each_pair do |key, value|
             case key
             when INDEX
               argvs[key.to_i] = Server.parse_argv(value)
-            else
-              instance_variable_set("@#{key}s", Server.parse_pairs(value))
+              attributes[key.to_i] = value
+            when "workflow"
+              hash = value.kind_of?(String) ? YAML.load(value) : value
+              unless hash.kind_of?(Hash)
+                raise ArgumentError, "non-hash workflow specified: #{value}"
+              end
+                        
+              hash.each_pair do |type, entries|
+                instance_variable_set("@#{type}s", Server.parse_pairs(entries))
+              end
             end 
           end