tap 0.10.1 → 0.11.0

data/lib/tap/tasks/load.rb

@@ -0,0 +1,112 @@
+module Tap
+  module Tasks
+    # :startdoc::manifest the default load task
+    #
+    # Load YAML-formatted data, as may be produced using Tap::Dump,
+    # and makes this data available for other tasks.  Load is often
+    # used as a gateway task to other tasks.
+    #
+    #   % tap run -- load FILEPATH --: [task]
+    #
+    # Load can select items from Hash or Array objects using one or
+    # more keys when only a subset is desired.  By default items are
+    # selected using [].  For more flexible selection, use match.
+    # 
+    # Match converts each of the keys to a Regexp.  For hashes, all
+    # values with a matching key will be selected.  For arrays, any
+    # item matching a regexp will be selected.
+    #
+    # Use the flags to flatten, compact, sort (etc) results before
+    # passing them on to the next task.
+    class Load < Tap::Task
+      
+      config :match, false, :short => :m, &c.switch      # match keys
+      config :flatten, false, :short => :f, &c.switch    # flatten results
+      config :compact, false, :short => :c, &c.switch    # compact results
+      config :unique, false, :short => :u, &c.switch     # uniq results
+      config :sort, false, :short => :s, &c.switch       # sort results
+      #config :preview, false, :short => :p, &c.switch    # logs result
+      
+      # Loads the input as YAML and selects objects using keys.  Input may
+      # be an IO, StringIO, or a filepath.  If keys are empty, the loaded
+      # object is returned directly.
+      #
+      # ==== Key Selection
+      # Keys select items from the loaded object using [] (ie obj[key]).
+      # If match==true, the behavior is different; each string key is
+      # converted into a Regexp and then arrays select items that match
+      # key:
+      #
+      #   results = []
+      #   array.each {|i| results << i if i =~ key}
+      #
+      # While hashes select values where the key matches key:
+      #
+      #   results = []
+      #   hash.each_pair {|k,v| results << v if k =~ key}
+      #
+      # Other objects raise an error when match is true.  
+      #
+      # ==== Post Processing
+      # After loading/key selection, the results may be processed (in this
+      # order) using flatten, compact, unique, and sort, each performing as
+      # you would expect.  
+      # 
+      def process(input, *keys)
+        
+        # load the input
+        obj = case input
+        when StringIO, IO
+          YAML.load(input.read)
+        else
+          log :load, input
+          YAML.load_file(input)
+        end
+        
+        # select results by key
+        results = case
+        when keys.empty? then obj
+        when match 
+          regexps = keys.collect {|key| Regexp.new(key.to_s) }
+          select_matching(obj, regexps)
+        else 
+          keys.collect do |key| 
+            index = key.kind_of?(String) ? YAML.load(key) : key
+            obj[index]
+          end
+        end
+        
+        # post-process results
+        results = results.flatten if flatten
+        results = results.compact if compact
+        results = results.uniq if unique
+        results = results.sort if sort
+        
+        #if preview
+          # should be a log or something
+          #puts results.inspect
+        #end
+        
+        results
+      end
+      
+      protected
+      
+      # selects items from obj which match one of the regexps.
+      def select_matching(obj, regexps) # :nodoc:
+        case obj
+        when Array
+          obj.select {|item| regexps.any? {|r| item =~ r} }
+        when Hash
+          results = []
+          obj.each_pair do |key, value|
+            results << value if regexps.any? {|r| key =~ r}
+          end
+          results
+        else
+          raise ArgumentError, "cannot match keys from a #{obj.class}"
+        end
+      end
+    end 
+  end
+end

data/lib/tap/tasks/rake.rb

@@ -16,38 +16,11 @@ module Tap
     # to access the rake help, and --help to access this help.
     #
     class Rake < Tap::Task
-    
-      # Modifies Rake::Application by adding a hook to the standard_exception_handling
-      # method.  This allows more fine-grained use of Rake::Applications by Tap.
-      module Application
-        def enq_top_level(app)
-          # takes the place of rake.top_level
-          if options.show_tasks
-            display_tasks_and_comments
-            exit
-          elsif options.show_prereqs
-            display_prerequisites
-            exit
-          else
-            top_level_tasks.each do |task_string|
-              name, args = parse_task_string(task_string)
-              task = self[name]
-            
-              unless task.kind_of?(Tap::Support::Executable)
-                Tap::Support::Executable.initialize(task, :invoke)
-              end
-            
-              app.enq(task, *args)
-            end
-          end  
-        end
-      end
-    
       class << self
       
-        # Overrides Tap::Support::FrameworkClass#instantiate to do  
+        # Overrides Tap::Support::FrameworkClass#parse! to do  
         # nothing so that all args get passed forward to rake.
-        def instantiate(argv, app=Tap::App.instance) # => instance, argv
+        def parse!(argv, app=Tap::App.instance) # => instance, argv
           if argv.include?('--help')
             puts help
             exit
@@ -55,21 +28,10 @@ module Tap
           [new({}, default_name, app), argv.collect {|arg| arg == '--rake-help' ? '--help' : arg}]
         end
       end
-    
-      #--
-      # def on_complete(override=false, &block)
-      #   @rake_tasks.each do |task|
-      #     task.on_complete(override, &block)
-      #   end
-      # end
-      #++
       
       def enq(*argv)
         rake = ::Rake.application
-        unless rake.kind_of?(Application)
-          rake.extend Application
-        end
-
+        
         # run as if from command line using argv
         current_argv = ARGV.dup
         begin
@@ -89,6 +51,7 @@ module Tap
       
         nil
       end
+      
     end
   end
 end

data/lib/tap/test/assertions.rb

@@ -0,0 +1,38 @@
+require 'tap/test/utils'
+
+module Tap
+  module Test
+    module Assertions
+      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 ==================
+#{Utils.whitespace_escape(a)}
+======================== but was ========================
+#{Utils.whitespace_escape(b)}
+=========================================================
+}
+        end
+      end
+    end
+  end
+end

data/lib/tap/test/env_vars.rb

@@ -22,7 +22,7 @@ module Tap
       
       # Returns true if the env_var(var) is set and matches /^true$/i
       def env_true?(var)
-        env(var) && env(var) =~ /^true$/i
+        (env(var) && env(var) =~ /^true$/i) ? true : false
       end
     end
   end

data/lib/tap/test/extensions.rb

@@ -0,0 +1,79 @@
+module Tap
+  
+  # Modules facilitating testing.  TapTest are specific to
+  # Tap, but SubsetTest and FileTest are more general in 
+  # their utility.
+  module Test
+    autoload(:SubsetTest, 'tap/test/subset_test')
+    autoload(:FileTest, 'tap/test/file_test')
+    autoload(:TapTest, 'tap/test/tap_test')
+    autoload(:ScriptTest, 'tap/test/script_test')
+    autoload(:Utils, 'tap/test/utils')
+    
+    module Extensions
+      def acts_as_subset_test
+        include Tap::Test::SubsetTest
+      end
+    
+      # Causes a TestCase to act as a file test, by including FileTest and
+      # instantiating class_test_root (a Tap::Root).  The root and directories 
+      # used by class_test_root may be specified as options.  
+      #
+      # Note: by default acts_as_file_test determines a root directory 
+      # <em>based on the calling file</em>.  Be sure to specify the root 
+      # directory manually if you call acts_as_file_test from a file that 
+      # isn't the test file.
+      def acts_as_file_test(options={})
+        include Tap::Test::FileTest
+      
+        options = {
+          :root => test_root_dir,
+          :directories => {
+            :input => 'input',
+            :output => 'output',
+            :expected => 'expected'}
+        }.merge(options)
+      
+        self.class_test_root = Tap::Root.new(options[:root], options[:directories])
+      end
+
+      # Causes a unit test to act as a tap test -- resulting in the following:
+      # - setup using acts_as_file_test
+      # - inclusion of Tap::Test::SubsetTest
+      # - inclusion of Tap::Test::InstanceMethods 
+      #
+      # Note: by default acts_as_tap_test determines a root directory 
+      # <em>based on the calling file</em>.  Be sure to specify the root 
+      # directory manually if you call acts_as_file_test from a file that 
+      # isn't the test file.
+      def acts_as_tap_test(options={})
+        acts_as_subset_test
+        acts_as_file_test({:root => test_root_dir}.merge(options))
+      
+        include Tap::Test::TapTest
+      end
+
+      def acts_as_script_test(options={})
+        acts_as_file_test({:root => test_root_dir}.merge(options))
+      
+        include Tap::Test::ScriptTest
+      end
+    
+      private
+    
+      # Infers the test root directory from the calling file.
+      #   'some_class.rb' => 'some_class'
+      #   'some_class_test.rb' => 'some_class'
+      def test_root_dir # :nodoc:
+        # caller[1] is considered the calling file (which should be the test case)
+        # note that caller entries are like this:
+        #   ./path/to/file.rb:10
+        #   ./path/to/file.rb:10:in 'method'
+        
+        calling_file = caller[1].gsub(/:\d+(:in .*)?$/, "")
+        calling_file.chomp(File.extname(calling_file)).chomp("_test") 
+      end
+    end
+  end
+end
+