bahuvrihi-tap 0.10.6 → 0.10.7

data/lib/tap/test/script_methods.rb

@@ -1,75 +0,0 @@
-require 'tap/test/subset_methods'
-require 'tap/test/script_methods/script_test'
-
-module Tap
-  module Test
-    module ScriptMethods
-      
-      def self.included(base)
-        super
-        base.send(:include, Tap::Test::SubsetMethods)  
-      end
-      
-      def assert_output_equal(a, b, msg=nil)
-        a = a[1..-1] if a[0] == ?\n
-        if a == b
-          assert true
-        else
-          flunk %Q{
-#{msg}
-==================== expected output ====================
-#{Utils.whitespace_escape(a)}
-======================== but was ========================
-#{Utils.whitespace_escape(b)}
-=========================================================
-}
-        end
-      end
-      
-      def assert_alike(a, b, msg=nil)
-        if b =~ a
-          assert true
-        else
-          flunk %Q{
-#{msg}
-================= expected output like ==================
-#{a}
-======================== but was ========================
-#{Utils.whitespace_escape(b)}
-=========================================================
-}
-        end
-      end
-      
-      def default_command_path
-        nil
-      end
-      
-      def script_test(test_dir=method_root.root)
-        subset_test("SCRIPT", "s") do
-          Tap::Root.chdir(test_dir, true) do  
-            Utils.with_argv do
-              puts "\n# == #{method_name}"
-
-              cmd = ScriptTest.new(default_command_path, env('stepwise')) do |expected, result, msg|
-                case expected
-                when String
-                  assert_output_equal(expected, result, msg)
-                when Regexp
-                  assert_alike(expected, result, msg)
-                end
-              end
-              
-              yield(cmd)
-            end
-          end
-        end
-      end
-      
-    end
-  end
-end
-
-
-
-

data/lib/tap/test/script_methods/regexp_escape.rb

@@ -1,94 +0,0 @@
-require 'tap/test/utils'
-
-module Tap
-  module Test
-    module ScriptMethods
-      
-      # RegexpEscape is a subclass of regexp that escapes all but the text in a
-      # special escape sequence.  This allows the creation of complex regexps
-      # to match, for instance, console output.
-      #
-      # The RegexpEscape.escape (or equivalently the quote) method does the
-      # work; all regexp-active characters are escaped except for characters
-      # enclosed by ':.' and '.:' delimiters.
-      #
-      #   RegexpEscape.escape('reg[exp]+ chars. are(quoted)')       # => 'reg\[exp\]\+\ chars\.\ are\(quoted\)'
-      #   RegexpEscape.escape('these are not: :.a(b*)c.:')          # => 'these\ are\ not:\ a(b*)c'
-      #
-      # In addition, all-period regexps are automatically upgraded to '.*?';
-      # use the '.{n}' notation to specify n arbitrary characters.
-      #
-      #   RegexpEscape.escape('_:..:_:...:_:....:')        # => '_.*?_.*?_.*?'
-      #   RegexpEscape.escape(':..{1}.:')                  # => '.{1}'
-      #
-      # RegexpEscape instances are initialized using the escaped input string
-      # and format the original string upon to_s, to simplify their use in 
-      # tests.
-      #
-      #   r = RegexpEscape.new %q{
-      #   a multiline
-      #   :...:
-      #   example}
-      #
-      #   r =~ %q{
-      #   a multiline
-      #   matching
-      #   example}  # => true
-      #
-      #   r !~ %q{
-      #   a failing multiline
-      #   example}  # => true
-      #
-      #   r.to_s 
-      #   # => %q{\n
-      #   # a multiline\n
-      #   # :...:\n
-      #   # example}
-      #
-      class RegexpEscape < Regexp
-        
-        # matches the escape sequence
-        ESCAPE_SEQUENCE = /:\..*?\.:/
-        
-        class << self
-        
-          # Escapes regexp-active characters in str, except for character
-          # delimited by ':.' and '.:'.  See the class description for
-          # details.
-          def escape(str)
-            substituents = []
-            str.scan(ESCAPE_SEQUENCE) do
-              regexp_str = $&[2...-2]
-              regexp_str = ".*?" if regexp_str =~ /^\.*$/
-              substituents << regexp_str
-            end
-            substituents << ""
-
-            splits = str.split(ESCAPE_SEQUENCE).collect do |split|
-              super(split)
-            end
-            splits << "" if splits.empty?
-            
-            splits.zip(substituents).to_a.flatten.join
-          end
-          
-          # Same as escape.
-          def quote(str)
-            escape(str)
-          end
-        end
-        
-        def initialize(str)
-          super(RegexpEscape.escape(str))
-          @original_str = str
-        end
-        
-        # Returns the original string for self, but with
-        # whitespace escaped as in Utils#whitespace_escape
-        def to_s
-          Utils.whitespace_escape(@original_str)
-        end
-      end
-    end
-  end
-end

data/lib/tap/test/script_methods/script_test.rb

@@ -1,109 +0,0 @@
-require 'tap/support/shell_utils'
-require 'tap/test/script_methods/regexp_escape'
-
-module Tap
-  module Test
-    module ScriptMethods
-      class ScriptTest
-        include Tap::Support::ShellUtils
-        
-        # The command path for self, returned by to_s
-        attr_accessor :command_path
-        
-        # An array of (command, message, expected, validation)
-        # entries, representing the accumulated test commands.
-        attr_reader :commands
-        
-        attr_reader :stepwise, :run_block
-        
-        def initialize(command_path=nil, stepwise=false, &run_block)
-          @command_path = command_path
-          @commands = []
-          @stepwise = stepwise
-          @run_block = run_block
-        end
-        
-        # Splits the input string, collecting single-line commands
-        # and expected results.  Nil will be used as the expected
-        # result if the result is whitespace, or not present.
-        #
-        #   cmd = ScriptTest.new
-        #   cmd.split %Q{
-        #   % command one
-        #   expected text for command one
-        #   % command two
-        #   % command three
-        #   expected text for command three
-        #   }  
-        #   # => [
-        #   # ["command one", "expected text for command one\n"],
-        #   # ["command two", nil],
-        #   # ["command three", "expected text for command three\n"]] 
-        #
-        def split(str)
-          str.split(/^%\s*/).collect do |s| 
-            next(nil) if s.strip.empty?
-            command, expected = s.split(/\n/, 2)
-            expected = nil if expected && expected.strip.empty?
-            [command.strip, expected]
-          end.compact
-        end
-        
-        def time(msg, command)
-          commands << [command, msg, nil, nil]
-        end
-        
-        def check(msg, command, use_regexp_escapes=true, &validation)
-          new_commands = split(command)
-          commands = new_commands.collect do |cmd, expected|
-            expected = RegexpEscape.new(expected) if expected && use_regexp_escapes
-            [cmd, msg, expected, validation]
-          end
-          
-          run(commands)
-        end
-
-        def match(msg, command, regexp=nil, &validation)
-          new_commands = split(command)
-          commands = new_commands.collect do |cmd, expected|
-            raise "expected text specified in match command" unless expected == nil
-            [cmd, msg, regexp, validation]
-          end
-          
-          run(commands)
-        end
-        
-        def run(commands)
-          commands.each_with_index do |(cmd, msg, expected, validation), i|
-            start = Time.now
-            result = capture_sh(cmd) {|ok, status, tempfile_path| }
-            elapsed = Time.now - start
-            
-            cmd_msg = commands.length > 1 ? "#{msg} (#{i})" : msg
-            run_block.call(expected, result, %Q{#{cmd_msg}\n% #{cmd}}) if expected
-            validation.call(result) if validation
-
-            if stepwise
-              print %Q{
-------------------------------------
-%s
-> %s
-%s
-Time Elapsed: %.3fs} % [cmd_msg, cmd, result, elapsed]
-
-              print "\nContinue? (y/n): "
-              break if gets.strip =~ /^no?$/i
-            else
-              puts "%.3fs : %s" % [elapsed, cmd_msg]
-            end
-          end
-        end
-      
-        # Returns the command path.
-        def to_s
-          command_path
-        end
-      end
-    end
-  end
-end

data/lib/tap/workflow.rb

@@ -1,161 +0,0 @@
-module Tap
-  
-  # Workflow is a specialized type of Task allowing the encapsulation and reuse of  
-  # workflow logic.  Workflows are still under construction.
-  #
-  # === Workflow Definition
-  #
-  # During initialization, Workflow executes the workflow method (by default the
-  # block provided to Workflow.new) to define the workflow logic.  This method
-  # defines one or more entry_points and zero or more exit points, as well as 
-  # the internal logic for the workflow.
-  #
-  #   Workflow.new do |w|
-  #     factor = w.config[:factor] || 1
-  #
-  #     t1 = Task.new {|task, input| input += 1 }
-  #     t2 = Task.new {|task, input| input += 10 }
-  #     t3 = Task.new {|task, input| input *= factor }
-  #   
-  #     w.app.sequence(t1, t2, t3)
-  #     w.entry_point = t1
-  #     w.exit_point = t3
-  #   end
-  #
-  # Or equivalently:
-  #
-  #   class SimpleSequence < Workflow
-  #     config :factor, 1
-  #
-  #     def workflow
-  #       t1 = Task.new {|task, input| input += 5 }
-  #       t2 = Task.new {|task, input| input += 3 }
-  #       t3 = Task.new {|task, input| input *= factor }
-  #   
-  #       app.sequence(t1, t2, t3)
-  #       self.entry_point = t1
-  #       self.exit_point = t3
-  #     end
-  #   end
-  #
-  # To facilitate the specification of entry and exit points, workflow
-  # can accomodate either single-task assignments or a collection.  By
-  # default both are hashes, but they can be reassigned:
-  # 
-  #   Workflow.new do |w| 
-  #     w.entry_point.class                           # => Hash
-  #     w.exit_point.class                            # => Hash
-  #     w.entry_point[:main] = Task.new
-  #   end
-  #
-  #   Workflow.new {|w| w.entry_point = Task.new }
-  #   Workflow.new {|w| w.entry_point = [Task.new, Task.new] }
-  #
-  # Access to the group of entry/exit points is standardized to an
-  # array via the entry_points and exit_points methods.
-  #
-  # === Workflow Behavior
-  #
-  # The entry points act as an enque batch; when the workflow is enqued, the 
-  # entry points are enqued.  The exit points act as an on_complete batch; their
-  # on_complete blocks are set for workflow.on_complete.  
-  #
-  #   w = SimpleSequence.new
-  #   w.enq(0)
-  #   app.run
-  #   app.results(w.exit_points)                      # => [8]
-  #
-  # The batching of entry and exit points is distinct from workflow.batch itself. 
-  # Workflows can be batched like Tasks, such that all entry points from all 
-  # workflows in a batch are enqued at once. 
-  #
-  #   w1 = SimpleSequence.new nil, :factor => 1
-  #   w2 = w1.initialize_batch_obj nil, :factor => -1
-  #
-  #   w1.enq(0)
-  #   app.run
-  #   app.results(w1.exit_points, w2.exit_points))    # => [8, -8]
-  #
-  class Workflow < Task
-
-    # The entry point for self.
-    attr_accessor :entry_point
-    
-    # The exit point for self.
-    attr_accessor :exit_point
-
-    # Creates a new Task with the specified attributes.
-    def initialize(config={}, name=nil, app=App.instance, &task_block)
-      super
-      initialize_workflow
-    end
-    
-    # Initializes a new batch object, running workflow to set the 
-    # instance-specific entry/exit points.  Raises an error if
-    # no entry points are defined.
-    def initialize_copy(orig)
-      super
-      initialize_workflow
-    end
-    
-    def initialize_workflow
-      @entry_point = {}
-      @exit_point = {}
-      workflow
-    end
-    
-    # Returns an array of entry points, determined from entry_point.
-    def entry_points
-      case @entry_point
-      when Hash then @entry_point.values
-      when Support::Executable then [@entry_point]
-      when Array then @entry_point
-      when nil then []
-      else raise "unable to determine entry points from entry_point: #{@entry_point}"
-      end
-    end
-    
-    # Returns an array of exit points, determined from exit_point.
-    def exit_points
-      case @exit_point
-      when Hash then @exit_point.values
-      when Support::Executable then [@exit_point]
-      when Array then @exit_point
-      when nil then []
-      else raise "unable to determine exit points from exit_point: #{@exit_point}"
-      end
-    end
-    
-    # Enqueues all entry points for self and self.batch to app 
-    # with the inputs. The number of inputs provided should match 
-    # the number of inputs required by all the entry points;
-    # if the entry points have different input requirements, they
-    # have to be enqued separately.
-    def unbatched_enq(*inputs)
-      entry_points.each do |task|
-        app.enq(task, *inputs)
-      end
-    end
-  
-    # Sets the on_complete_block for all exit points for self and 
-    # self.batch. Use unbatched_on_complete to set the on_complete_block
-    # for just self.exit_points.
-    def unbatched_on_complete(override=false, &block)
-      exit_points.each do |task|
-        task.on_complete(override, &block)
-      end
-      self
-    end
-   
-    # The workflow definition method.  By default workflow
-    # simply calls the task_block.  In subclasses, workflow
-    # should be overridden to provide the workflow definition.
-    def workflow
-      task_block.call(self) if task_block
-    end
-    
-    def process(*inputs)
-      enq(*inputs)
-    end
-  end
-end