bahuvrihi-tap 0.10.6 → 0.10.7

data/lib/tap/spec/file_methods.rb

@@ -1,16 +0,0 @@
-require 'tap/spec/adapter'
-require 'tap/test/file_methods'
-require 'tap/spec/file_methods_class'
-
-module Tap
-  module Spec
-    module FileMethods
-      def self.included(base)
-        super
-        base.send(:include, Tap::Spec::Adapter)
-        base.send(:include, Tap::Test::FileMethods)
-        base.extend Tap::Spec::FileMethodsClass
-      end
-    end
-  end
-end

data/lib/tap/spec/file_methods_class.rb

@@ -1,13 +0,0 @@
-module Tap
-  module Spec
-    module FileMethodsClass
-      def trs
-        @trs ||= (superclass.respond_to?(:trs) ? superclass.trs : nil)
-      end
-      
-      def file_test_root
-        super.chomp("_spec") 
-      end
-    end
-  end
-end

data/lib/tap/spec/subset_methods.rb

@@ -1,14 +0,0 @@
-require 'tap/spec/adapter'
-require 'tap/test/subset_methods'
-
-module Tap
-  module Spec
-    module SubsetMethods
-      def self.included(base)
-        super
-        base.send(:include, Tap::Spec::Adapter)
-        base.send(:include, Tap::Test::SubsetMethods)
-      end
-    end
-  end
-end

data/lib/tap/support/batchable.rb

@@ -1,47 +0,0 @@
-require 'tap/support/batchable_class'
-
-module Tap
-  module Support
-
-    # Batchable encapsulates the methods used to support batching
-    # of tasks. Classes including Batchable should call <tt>super</tt>
-    # during initialization to initialize batch, or they should 
-    # initialize batch themselves.
-    #
-    # See the 'Batches' section in the Tap::Task documentation for 
-    # details on how Batchable works in practice.
-    module Batchable
-    
-      def self.included(mod)
-        mod.extend Support::BatchableClass if mod.kind_of?(Class)
-      end
-      
-      # The object batch.
-      attr_reader :batch
-      
-      def initialize(batch=[])
-        @batch = batch
-        @batch << self
-      end
-    
-      # Returns true if the batch size is greater than one 
-      # (the one being self).  
-      def batched?
-        batch.length > 1
-      end
-
-      # Returns the index of the self in batch.
-      def batch_index
-        batch.index(self)
-      end
-      
-      # Initializes a new batch object and adds the object to batch.
-      # The object will be a duplicate of self.
-      def initialize_batch_obj
-        obj = self.dup
-        batch << obj
-        obj
-      end
-    end
-  end
-end

data/lib/tap/support/batchable_class.rb

@@ -1,107 +0,0 @@
-module Tap
-  module Support
-    
-    # BatchableClass encapsulates class methods related to Batchable.
-    module BatchableClass
-      
-      # Merges the batches for the specified objects.  All objects 
-      # sharing the individual object batches will be affected, even 
-      # if they are not listed explicitly as an input.
-      #
-      #  t1 = Tap::Task.new
-      #  t2 = Tap::Task.new
-      #  t3 = t2.initialize_batch_obj
-      #
-      #  Tap::Task.batch(t1, t2)
-      #  t3.batch                    # => [t1,t2,t3]
-      #
-      # Returns the new batch.
-      def batch(*batchables)
-        merged = []
-        batches = batchables.collect {|batchable| batchable.batch }.uniq
-        batches.each do |batch| 
-           merged.concat(batch)
-           batch.clear
-         end
-        merged.uniq!
-        batches.each {|batch| batch.concat(merged) }
-        merged
-      end
-      
-      protected
-      
-      # Redefines the specified method(s) as batched methods.  The existing method
-      # is renamed as <tt>unbatched_method</tt> and <tt>method</tt> redefined to 
-      # call <tt>unbatched_method</tt> on each object in the batch.
-      #
-      #   def process(one, two)
-      #     ...
-      #   end
-      #   batch_function(:process)
-      #
-      # Is equivalent to:
-      #
-      #   def unbatched_process(one, two)
-      #     ...
-      #   end
-      #
-      #   def process(one, two)
-      #     batch.each do |t|
-      #      t.unbatched_process(one, two)
-      #     end
-      #     self
-      #   end
-      #
-      # The batched method will accept/pass as many arguments as are defined for
-      # the unbatched method.  Splats are supported, and blocks are supported too 
-      # by passing a block to batch_function:
-      #
-      #   def process(arg, *args, &block)
-      #     ...
-      #   end
-      #   batch_function(:process) {}
-      #
-      # Is equivalent to:
-      #
-      #   def unbatched_process(arg, *args, &block)
-      #     ...
-      #   end
-      #
-      #   def process(*args, &block)
-      #     batch.each do |t|
-      #      t.unbatched_process(*args, &block)
-      #     end
-      #     self
-      #   end
-      #
-      # Obviously there are limitations to batch_function, most notably batching
-      # functions with default values.  In these cases, batch functionality
-      # must be implemented manually.
-      def batch_function(*methods)
-        methods.each do |method_name|
-          unbatched_method = "unbatched_#{method_name}"
-          if method_defined?(unbatched_method)
-            raise "unbatched method already defined: #{unbatched_method}"
-          end
-          
-          arity = instance_method(method_name).arity
-          args = case
-          when arity < 0 then "*args"
-          else Array.new(arity) {|index| "arg#{index}" }.join(", ")
-          end 
-          args += ", &block" if block_given?
- 
-          class_eval %Q{
-            alias #{unbatched_method} #{method_name}
-            def #{method_name}(#{args})
-              batch.each do |t|
-                t.#{unbatched_method}(#{args})
-              end
-              self
-            end
-          }
-        end
-      end
-    end 
-  end
-end

data/lib/tap/support/declarations.rb

@@ -1,131 +0,0 @@
-require 'tap/support/lazydoc/declaration'
-
-module Tap
-  module Support
-    module Declarations
-      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)
-      end
-
-      def self.extended(base)
-        set_declaration_base(base)
-      end
-      
-      def tasc(name, configs={}, &block)
-        declare(Tap::Task, name, configs, &block)
-      end
-      
-      protected
-
-      def config(key, value=nil, options={}, &block)
-        if options[:desc] == nil
-          caller[0] =~ Lazydoc::CALLER_REGEXP
-          options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
-        end 
-
-        [:config, key, value, options, block]
-      end
-
-      def config_attr(key, value=nil, options={}, &block)
-        if options[:desc] == nil
-          caller[0] =~ Lazydoc::CALLER_REGEXP
-          options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
-        end
-
-        [:config_attr, key, value, options, block]
-      end
-
-      def c
-        Support::Validation
-      end
-
-      private
-      
-      def arity(block)
-        arity = block.arity
-        
-        case
-        when arity > 0 then arity -= 1
-        when arity < 0 then arity += 1
-        end
-        
-        arity
-      end
-      
-      def parse(declaration)
-        # Extract name and dependencies from declaration
-        name, dependencies = case declaration
-        when Hash then declaration.to_a[0]
-        else [declaration, []]
-        end
-        
-        unless dependencies.kind_of?(Array)
-          raise ArgumentError, "dependencies should be specified as an array (was #{dependencies.class})"
-        end
-        
-        unless dependencies.empty?
-          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
-        
-        [name, dependencies]
-      end
-      
-      def declare(klass, declaration, configs={}, options={}, &block)
-        # parse the declaration
-        name, dependencies = parse(declaration)
-        
-        # 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)
-        
-        # generate the subclass
-        subclass = klass.subclass(name, configs, dependencies, options, &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)
-
-        arity = options[:arity] || (block_given? ? block.arity : -1)
-        comment = Lazydoc::Comment.new
-        comment.subject = case
-        when arity > 0
-          Array.new(arity, "INPUT").join(' ')
-        when arity < 0
-          array = Array.new(-1 * arity - 1, "INPUT")
-          array << "INPUTS..."
-          array.join(' ')
-        else ""
-        end
-        lazydoc[subclass.to_s]['args'] ||= comment
-        
-        subclass
-      end
-      
-    end
-  end
-end

data/lib/tap/support/lazydoc/declaration.rb

@@ -1,20 +0,0 @@
-module Tap
-  module Support
-    module Lazydoc
-      class Declaration < Comment
-        def resolve(lines)
-          super
-            
-          @subject = case
-          when content.empty? || content[0][0].to_s !~ /^::desc(.*)/ then ""
-          else
-            content[0].shift
-            $1.strip
-          end
-            
-          self
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-module Tap
-  module Support
-    module Parsers
-      class Base
-        class << self
-          # Parses the input string as YAML, if the string matches the YAML document 
-          # specifier (ie it begins with "---\s*\n").  Otherwise returns the string.
-          #
-          #   str = {'key' => 'value'}.to_yaml       # => "--- \nkey: value\n"
-          #   Tap::Script.parse_yaml(str)            # => {'key' => 'value'}
-          #   Tap::Script.parse_yaml("str")          # => "str"
-          def parse_yaml(str)
-            str =~ /\A---\s*\n/ ? YAML.load(str) : str
-          end
-        end
-        
-        attr_reader :argvs
-        attr_reader :rounds
-        attr_reader :sequences
-        attr_reader :forks
-        attr_reader :merges
-        attr_reader :sync_merges
-        
-        def build(env, app)
-          # attempt lookup and instantiate the task class
-          task_declarations = argvs.collect do |argv|
-            pattern = argv.shift
-
-            const = env.search(:tasks, pattern) or raise ArgumentError, "unknown task: #{pattern}"
-            task_class = const.constantize or raise ArgumentError, "unknown task: #{pattern}"
-            task_class.instantiate(argv, app)
-          end
-
-          # remove tasks used by the workflow
-          tasks = targets.collect do |index|
-            task, args = task_declarations[index]
-
-            unless args.empty?
-              raise ArgumentError, "workflow target receives args: #{task} [#{args.join(', ')}]" 
-            end
-
-            tasks[index] = nil
-            task
-          end
-
-          # build the workflow
-          [:sequence, :fork, :merge, :sync_merge].each do |type|
-            send("#{type}s").each do |source, targets|
-              source.send(type, *targets.collect {|t| tasks[t] })
-            end
-          end
-
-          # build queues
-          queues = rounds.collect do |round|
-            round.each do |index|
-              task, args = task_declarations[index]
-              task.enq(*args) if task
-            end
-
-            app.queue.clear
-          end
-          queues.delete_if {|queue| queue.empty? }
-
-          queues
-        end
-        
-        protected
-        
-        def targets
-          results = sequences.collect {|source, targets| targets } +
-          forks.collect {|source, targets| targets } +
-          merges.collect {|target, sources| target } +
-          sync_merges.collect {|target, sources| target }
-          
-          results.flatten.uniq.sort
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-require 'tap/support/parsers/base'
-
-module Tap
-  module Support
-    module Parsers
-      
-      # rounds syntax
-      # 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
-      # ....
-      
-      class Server < Base
-        
-        class << self
-          def parse_argv(hash)
-            raise ArgumentError, "no task specified" unless hash.has_key?('tasc')
-
-            # parse task
-            argv = [hash.delete('tasc')]
-            
-            # parse configs
-            configs = hash.delete('config')
-            configs = YAML.load(configs) if configs.kind_of?(String)
-            
-            case configs
-            when Hash
-              configs.each_pair do |key, value|
-                argv << "--#{key}"
-                argv << value
-              end
-            when nil
-            else raise ArgumentError, "non-hash configs specified: #{configs}"
-            end
-            
-            # parse inputs
-            inputs = hash.delete('inputs')
-            inputs = YAML.load(inputs) if inputs.kind_of?(String)
-            
-            case inputs
-            when Array then argv.concat(inputs)
-            when nil
-            else raise ArgumentError, "non-array inputs specified: #{inputs}"
-            end
-            
-            argv
-          end
-          
-          def parse_pairs(values)
-            [*values].collect do |value|
-              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)
-              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
-          
-          @rounds ||= []
-          @sequences ||= []
-          @forks ||= []
-          @merges ||= []
-          @sync_merges ||= []
-        end
-      end
-    end
-  end
-end