tap 0.9.1 → 0.10.0

data/lib/tap/test.rb

@@ -25,9 +25,9 @@ end
 
 module Tap
   
-  # Modules facilitating testing.  Tap::Test::TapMethods are specific to
-  # Tap, but the other modules Tap::Test::SubsetMethods and 
-  # Tap::Test::FileMethods are more general in their utility.
+  # Modules facilitating testing.  TapMethods are specific to
+  # Tap, but SubsetMethods and FileMethods are more general in 
+  # their utility.
   module Test
   end
 end

data/lib/tap/test/env_vars.rb

@@ -1,7 +1,7 @@
 module Tap
   module Test
     
-    # Provides a method for case-insensitive access to the ENV variables
+    # Provides for case-insensitive access to the ENV variables
     module EnvVars
       
       # Access to the case-insensitive ENV variables.  Raises an error
@@ -20,7 +20,7 @@ module Tap
         end
       end
       
-      # Returns true if the env_var(var) is set and matches /^true%/i
+      # Returns true if the env_var(var) is set and matches /^true$/i
       def env_true?(var)
         env(var) && env(var) =~ /^true$/i
       end

data/lib/tap/test/file_methods.rb

@@ -2,13 +2,15 @@ require 'tap/root'
 require 'tap/test/env_vars'
 require 'test/unit'
 require 'fileutils'
-require 'active_support/core_ext/class'
 
 module Test # :nodoc:
   module Unit # :nodoc:
     class TestCase
       class << self
         
+        # Access the test root structure (a Tap::Root)
+        attr_accessor :trs
+        
         # Causes a TestCase to act as a file test, by instantiating a class Tap::Root 
         # (trs), and including FileMethods.  The root and directories used to 
         # instantiate trs can be specified as options.  By default file_test_root
@@ -25,10 +27,7 @@ module Test # :nodoc:
           }.merge(options)
 
           directories = options[:directories]
-          trs = Tap::Root.new(options[:root], directories)
-    
-          write_inheritable_attribute(:trs, trs)
-          class_inheritable_reader :trs
+          self.trs = Tap::Root.new(options[:root], directories)
       
           include Tap::Test::FileMethods
         end
@@ -57,8 +56,7 @@ end
 module Tap
   module Test  
     
-    # == Overview
-    #
+
     # FileMethods sets up a TestCase with methods for accessing and utilizing
     # test-specific files and directories.  Each class that acts_as_file_test
     # is set up with a Tap::Root structure (trs) that mediates the creation of 
@@ -137,6 +135,10 @@ module Tap
     #   % rake test keep_outputs=true
     #   % tap run test keep_failures=true
     #
+    #
+    # === Class Methods
+    # 
+    # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] for documentation of the class methods added by FileMethods.
     module FileMethods
       include Tap::Test::EnvVars
   
@@ -152,11 +154,14 @@ module Tap
         end
       end
       
+      attr_reader :method_tempfiles
+      
       # Setup deletes the the output directory if it exists, and tries to remove the
       # method root directory so the directory structure is reset before running the
       # test, even if outputs were left over from previous tests.
       def setup
         super
+        @method_tempfiles = []
         clear_method_dir(:output)
         try_remove_dir(method_root)
       end
@@ -258,21 +263,20 @@ module Tap
       # - If the directory for the filepath does not exist, the directory will be created
       # - Like all files in the output directory, tempfiles will be deleted by the default 
       #   +teardown+ method
-      def output_tempfile(filename=method_name_str)
-        n = 0
+      def method_tempfile(filename=method_name_str, &block)
         ext = File.extname(filename)
         basename = filename.chomp(ext)
-        filepath = make_tmpname(basename, n, ext)
-        while File.exists?(filepath)
-          n += 1
-          filepath = make_tmpname(basename, n, ext)
-        end
+        filepath = method_filepath(:output, sprintf('%s%d.%d%s', basename, $$, method_tempfiles.length, ext))
+        method_tempfiles << filepath
       
         dirname = File.dirname(filepath)
         FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
+        if block_given?
+          File.open(filepath, "w", &block)
+        end
         filepath
       end
-
+      
       # Yields to the input block for each pair of entries in the input 
       # arrays.  An error is raised if the input arrays do not have equal 
       # numbers of entries.
@@ -368,11 +372,6 @@ module Tap
         flunk "File compare failed:\n" + errors.join("\n") unless errors.empty?
       end
 
-      private
-    
-      def make_tmpname(basename, n, ext="") # :nodoc:
-        method_filepath(:output, sprintf('%s%d.%d%s', basename, $$, n, ext))
-      end
     end
   end
 end

data/lib/tap/test/script_methods.rb

@@ -0,0 +1,144 @@
+require 'test/unit'
+require 'tap/test/file_methods'
+require 'tap/test/subset_methods'
+#require 'tap/support/shell_utils'
+
+module Test # :nodoc:
+  module Unit # :nodoc:
+    class TestCase
+      class << self
+
+        def acts_as_script_test(options={})
+          options = options.inject({:root => file_test_root}) do |hash, (key, value)|
+            hash[key.to_sym || key] = value
+            hash
+          end
+          acts_as_file_test(options)
+          include Tap::Test::SubsetMethods
+          include Tap::Test::ScriptMethods
+        end
+        
+      end
+    end
+  end
+end
+
+module Tap
+  module Test
+  
+    module ScriptMethods
+      class CommandTest  
+        attr_accessor :command_path
+        attr_reader :commands
+        
+        def initialize
+          @command_path = nil
+          @commands = []
+        end
+        
+        def check(argstr, msg=nil, expected=nil, &block)
+          commands << ["#{command_path}#{argstr}", msg, expected, block]
+        end
+        
+        def check_cmd(cmd, msg=nil, expected=nil, &block)
+          commands << [cmd, msg, expected, block]
+        end
+      end
+      
+      include Tap::Support::ShellUtils
+      
+      def assert_output_equal(a, b, cmd, msg)
+        a = a[1..-1] if a[0] == ?\n
+        if a == b
+          assert true
+        else
+          flunk %Q{
+#{msg}
+% #{cmd}
+==================== expected output ====================
+#{a.gsub(/\t/, "\\t").gsub(/\r\n/, "\\r\\n\n").gsub(/\n/, "\\n\n")}
+======================== but was ========================
+#{b.gsub(/\t/, "\\t").gsub(/\r\n/, "\\r\\n\n").gsub(/\n/, "\\n\n")}
+=========================================================
+}
+        end
+      end
+      
+      def assert_alike(a, b, cmd, msg)
+        if b =~ a
+          assert true
+        else
+          flunk %Q{
+#{msg}
+% #{cmd}
+================= expected output like ==================
+#{a}
+======================== but was ========================
+#{b.gsub(/\t/, "\\t").gsub(/\r\n/, "\\r\\n\n").gsub(/\n/, "\\n\n")}
+=========================================================
+}
+        end
+      end
+      
+      def script_test(test_dir=method_dir(:output))
+        subset_test("SCRIPT", "s") do
+          test = CommandTest.new
+          yield(test)
+          
+          current_dir = Dir.pwd
+          current_argv = ARGV.dup
+          begin
+            ARGV.clear
+            make_test_directories
+            Dir.chdir(test_dir)
+            
+            puts "\n# == #{method_name}"
+        
+            test.commands.each do |cmd, msg, expected, block|
+              start = Time.now
+              result = capture_sh(cmd) {|ok, status, tempfile_path| }
+              elapsed = Time.now - start
+
+              case expected
+              when String
+                assert_output_equal(expected, result, cmd, msg)
+              when Regexp
+                assert_alike(expected, result, cmd, msg)
+              end
+              
+              if block
+                block.call(result)
+              end
+              
+              if env('stepwise') || (expected == nil && block == nil)
+                print %Q{
+------------------------------------
+%s
+> %s
+%s
+Time Elapsed: %.3fs} % [msg, cmd, result, elapsed]
+
+                if env('stepwise')
+                  print "\nContinue? (y/n): "
+                  break if gets.strip =~ /^no?$/i
+                end
+              else            
+                puts "%.3fs : %s" % [elapsed, msg]
+              end
+            end
+          ensure
+            Dir.chdir(current_dir)
+            ARGV.clear
+            ARGV.concat(current_argv)
+          end
+          
+        end
+      end
+      
+    end
+  end
+end
+
+
+
+

data/lib/tap/test/subset_methods.rb

@@ -244,7 +244,7 @@ module Tap
     #
     # === Class Methods
     # 
-    # See Test::Unit::TestCase for documentation of the class methods added by SubsetMethods
+    # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] for documentation of the class methods added by SubsetMethods
     module SubsetMethods
       include Tap::Test::EnvVars
   

data/lib/tap/test/tap_methods.rb

@@ -15,7 +15,10 @@ module Test # :nodoc:
         # based on the calling file. Be sure to specify the root directory explicitly 
         # if you call acts_as_file_test from a file that is NOT meant to be test file.
         def acts_as_tap_test(options={})
-          options = {:root => file_test_root}.merge(options.symbolize_keys)
+          options = options.inject({:root => file_test_root}) do |hash, (key, value)|
+            hash[key.to_sym || key] = value
+            hash
+          end
           acts_as_file_test(options)
           
           include Tap::Test::SubsetMethods
@@ -59,6 +62,10 @@ module Tap
     # Tap-specific testing methods to help with testing Tasks, such as the
     # checking of audits and test-specific modification of application 
     # configuration.
+    #
+    # === Class Methods
+    # 
+    # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] for documentation of the class methods added by TapMethods.
     module TapMethods
       
       # Returns the test-method-specific application.
@@ -71,10 +78,7 @@ module Tap
       # Also makes sure Tap::App.instance returns the test method app.
       def setup
         super
-        @app = Tap::App.new(
-          :root => method_root, 
-          :directories => trs.directories,
-          :absolute_paths => trs.absolute_paths)
+        @app = Tap::App.new(app_config)
         Tap::App.instance = @app
       end
       
@@ -191,74 +195,36 @@ module Tap
       
       public
       
-      #
-      # application methods
-      #
-
-      # Applies the input options to the specified app for the duration
-      # of the block.  Unless merge_with_existing is false, the input
-      # options will be merged with the existing options; otherwise
-      # the app options will be reconfigured to just the inputs.
-      #
-      # For convenience, with_options is setup such that options 
-      # {:debug => true, :quiet => true} are implicitly specified.  
-      # Overrides are respected.
-      #
-      #   app = Tap::App.new(:options => {:one => 1, :two => 2})
-      #
-      #   with_options({:one => 'one', :quiet => false}, app) do 
-      #     app.options.marshal_dump     # => {:one => 'one', :two => 2, :debug => true, :quiet => false}
-      #   end
-      #
-      #   app.options.marshal_dump       # => {:one => 1, :two => 2}
-      #
-      def with_options(options={}, app=self.app, merge_with_existing=true, &block)
-        app_config = {:options => options}
-        with_config(app_config, app, merge_with_existing, &block)
+      # The configurations used to initialize self.app
+      def app_config
+        { :root => method_root, 
+          :directories => trs.directories,
+          :absolute_paths => trs.absolute_paths,
+          :quiet => true, 
+          :debug => true}
       end
       
-      # Applies the input configurations to the specified app for the 
-      # duration of the block.  Unless merge_with_existing is false,
-      # the input configurations will be merged with the existing 
-      # configurations; otherwise the app will be reconfigured to 
-      # using the inputs as specified.
-      #
-      # For convenience, with_config is setup such that options 
-      # {:debug => true, :quiet => true} are implicitly specified.  
-      # Overrides are respected.
+      # Reconfigures app with the input configurations for the 
+      # duration of the block.
       #
-      #   app = Tap::App.new(:directories => {:dir => 'dir', :alt => 'alt_dir'})
-      #   tmp_config = {
-      #     :directories => {:alt => 'another', :new => 'new_dir'},
-      #     :options => {:one => 1, :quiet => false}}
-      #
-      #   with_config(tmp_config, app) do 
-      #     app.directories              # => {:dir => 'dir', :alt => 'another', :new => 'new_dir'}
-      #     app.options.marshal_dump     # => {:one => 1, :debug => true, :quiet => false}
+      #   app = Tap::App.new(:quiet => true, :debug => false)
+      #   with_config({:quiet => false}, app) do 
+      #     app.quiet                    # => false
+      #     app.debug                    # => false
       #   end
       #
-      #   app.directories                # => {:dir => 'dir', :alt => 'alt_dir'}
-      #   app.options.marshal_dump       # => {}
+      #   app.quiet                      # => true
+      #   app.debug                      # => false
       #
-      def with_config(app_config={}, app=self.app, merge_with_existing=true, default_options={:debug => true, :quiet => true}, &block)
+      def with_config(config={}, app=self.app, &block)
         begin
-          hold = app.config
-          
-          app_config[:options] = default_options.merge(app_config[:options] || {})
-          if merge_with_existing
-            hold.each_pair do |key, value|
-              next unless app_config.has_key?(key)
-              next unless value.kind_of?(Hash)
-                
-              app_config[key] = value.merge(app_config[key])
-            end
-          end
+          hold = app.config.to_hash
           
-          app.reconfigure(app_config)
+          app.reconfigure(config)
           
           yield block if block_given?
         ensure
-          app.reconfigure(hold)
+          app.send(:initialize_config, hold)
         end
       end
       

data/lib/tap/workflow.rb

@@ -1,11 +1,7 @@
 module Tap
   
-  # == Overview
-  #
-  # App can build workflows directly, using methods like sequence, merge, and
-  # multithread, but these workflows are hard to abstract and resuse.  Workflow
-  # is a specialized type of Task allows the encapsulation and reuse of workflow 
-  # logic.  See Tap::Task for the shared documentation.
+  # Workflow is a specialized type of Task allowing the encapsulation and reuse of  
+  # workflow logic.  Workflows are still under construction.
   #
   # === Workflow Definition
   #
@@ -81,9 +77,8 @@ module Tap
   #   app.results(w1.exit_points, w2.exit_points))    # => [8, -8]
   #
   class Workflow 
-    include Support::Configurable
-    extend Support::CommandLineMethods
-    
+    include Support::Framework
+
     # The entry point for self.
     attr_accessor :entry_point
     
@@ -94,24 +89,18 @@ module Tap
     attr_reader :task_block
     
     # Creates a new Task with the specified attributes.
-    def initialize(name=nil, config={}, app=App.instance, &task_block)
+    def initialize(config={}, name=nil, app=App.instance, &task_block)
+      super(config, name, app)
       @task_block = (task_block == nil ? default_task_block : task_block)
-      super(name, config, app)
+      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_batch_obj(name=nil, config={})
-      task = super(name, config)
-      
-      task.entry_point = {}
-      task.exit_point = {}
-      task.workflow
-      
-      raise WorkflowError.new("No entry points defined") if task.entry_points.empty?
-      
-      task
+    def initialize_copy(orig)
+      super
+      initialize_workflow
     end
     
     # Returns an array of entry points, determined from entry_point.
@@ -142,33 +131,24 @@ module Tap
     # if the entry points have different input requirements, they
     # have to be enqued separately.
     def enq(*inputs)
-      batch.each {|t| t.unbatched_enq(*inputs) }
-      self
-    end
-    
-    # Enques all entry points to app with the inputs.
-    def unbatched_enq(*inputs)
       entry_points.each do |task|
         app.enq(task, *inputs)
       end
-      self
     end
     
+    batch_function :enq
+    
     # 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 on_complete(override=false, &block)
-      batch.each {|t| t.unbatched_on_complete(override, &block)}
-      self
-    end
-    
-    # Sets the on_complete_block for all exit points for self.
-    def unbatched_on_complete(override=false, &block)
       exit_points.each do |task|
         task.on_complete(override, &block)
       end
       self
     end
+    
+    batch_function(:on_complete) {}
 
     # The workflow definition method.  By default workflow
     # simply calls the task_block.  In subclasses, workflow
@@ -189,13 +169,16 @@ module Tap
       input == nil ? @name : File.join(@name, input)
     end
     
-    # Returns name
-    def to_s
-      name
-    end
-    
     protected
     
+    def initialize_workflow
+      @entry_point = {}
+      @exit_point = {}
+      
+      workflow
+      raise WorkflowError.new("No entry points defined") if entry_points.empty?
+    end
+    
     # Hook to set a default task block.  By default, nil.
     def default_task_block
       nil