tap 0.10.0 → 0.10.1

data/lib/tap/support/manifest.rb

@@ -1,88 +1,151 @@
+require 'tap/root'
+
 module Tap
   module Support
-    class Manifest 
-      
+    class Manifest
       class << self
-        def glob_method(name)
-          "manifest_glob_#{name}".to_sym
-        end
-        
-        def map_method(name)
-          "manifest_map_#{name}".to_sym
+        def normalize(key)
+          key.to_s.downcase.gsub(/\s/, "_").delete(":")
         end
       end
       
-      DEFAULT_MAP_METHOD = :manifest_map
- 
+      include Enumerable
+      
+      # An array of (key, value) entries in self.
       attr_reader :entries
-      attr_reader :map_method
-      attr_reader :paths
-      attr_reader :path_index
       
-      def initialize(name, source)
-        @entries = []
-
-        @map_method = Manifest.map_method(name)
-        @map_method = DEFAULT_MAP_METHOD if !source.respond_to?(@map_method)
-        
-        @paths = source.send(Manifest.glob_method(name)).uniq
-        @path_index = 0
+      # An array of search_paths to identify entries.
+      attr_reader :search_paths
+      
+      # The index of the search_path that will be searched
+      # next when building the manifest.
+      attr_reader :search_path_index
+      
+      def initialize(search_paths)
+        self.search_paths = search_paths
+      end
+      
+      # Returns an array of the entries keys.
+      def keys
+        entries.collect {|(key, value)| key }
       end
       
-      def complete?
-        @path_index == paths.length
+      # Returns an array of the entries values.
+      def values
+        entries.collect {|(key, value)| value }
       end
       
-      def each_path
-        return(false) if complete?
-
-        n_to_skip = @path_index
-        paths.each do |context, path|
-          if n_to_skip > 0
-            n_to_skip -= 1
-            next
-          end
-          
-          @path_index += 1
-          yield(context, path)
-        end
-        
-        true
+      # True if entries are empty.
+      def empty?
+        entries.empty?
       end
       
-      # Checks that the manifest does not already assign key a conflicting path,
-      # then adds the (key, path) pair to manifest.
-      def store(entry)
-        existing_key, existing_path = entries.find {|(key, path)| key == entry[0] } 
-        
-        if existing_key && existing_path != entry[1]
-          raise ManifestConflict, "multiple paths for key '#{existing_key}': ['#{existing_path}', '#{entry[1]}']"
-        end
+      def search_paths=(search_paths)
+        @entries = []
+        @search_paths = search_paths
+        @search_path_index = 0
+      end
       
-        entries << entry
+      # Clears entries and sets the search_path_index to zero.
+      def reset
+        @entries.clear
+        @search_path_index = 0
       end
       
-      def keys
-        entries.collect {|(key, value)| key }
+      # Builds the manifest, identifying all entries from search_paths.
+      # Returns self.
+      def build
+        each {|k, v|} unless built?
+        self
       end
       
-      def values
-        entries.collect {|(key, value)| value }
+      # True if all search paths have been checked for entries
+      # (ie search_path_index == search_paths.length).
+      def built?
+        @search_path_index == search_paths.length
+      end
+      
+      # Abstract method which should return each (key, value) entry
+      # for a given search path.  Raises a NotImplementedError
+      # if left not implemented.
+      def entries_for(search_path)
+        [[search_path, search_path]]
+      end
+      
+      # Adds the (key, value) pair to entries and returns the new entry.
+      # Checks that entries does not already assign key a conflicting value;
+      # raises an error if this is the case, or returns the existing entry.
+      #
+      # Keys are normalized using Manifest.normalize before storing.
+      def store(key, value)
+        key = Manifest.normalize(key)
+        existing = entries.find {|(k, v)| key == k } 
+        
+        if existing
+          if existing[1] != value
+            raise ManifestConflict.new(key, value, existing[1])
+          else
+            return existing
+          end
+        end
+        
+        new_entry = [key, value]
+        entries << new_entry
+        new_entry
       end
       
-      def mini_map
-        return [] if entries.empty?
+      # Iterates over each (key, value) entry in self, dynamically identifying entries 
+      # from search_paths if necessary.  New entries are identifed using the each_for
+      # method.
+      def each
+        entries.each do |key, path| 
+          yield(key, path) 
+        end
         
+        unless built?
+          n_to_skip = @search_path_index
+          search_paths.each do |search_path|
+            # advance to the current search path
+            if n_to_skip > 0
+              n_to_skip -= 1
+              next
+            end
+            @search_path_index += 1
+            
+            # collect new entries and yield afterwards to ensure
+            # that all entries for the search_path get stored
+            new_entries = entries_for(*search_path)
+            next if new_entries == nil
+            
+            new_entries.each {|(key, value)| store(key, value) }
+            new_entries.each {|(key, value)| yield(key, value) }
+          end
+        end
+      end
+      
+      # Returns an array of (mini_key, value) pairs, matching
+      # entries by index.
+      def minimize
         hash = {}
-        Root.minimize(keys) do |path, mini_path|
+        Tap::Root.minimize(keys) do |path, mini_path|
           hash[path] = mini_path
         end
         
         entries.collect {|path, value| [hash[path], value] }
       end
       
+      protected
+
       # Raised when multiple paths are assigned to the same manifest key.
       class ManifestConflict < StandardError
+        attr_reader :key, :value, :existing
+        
+        def initialize(key, value, existing)
+          @key = key
+          @value = value
+          @existing = existing
+          super("attempted to store '%s': %s\nbut already was\n%s" % [key, value, existing])
+        end
       end
     end
   end

data/lib/tap/tasks/rake.rb

@@ -1,4 +1,5 @@
 require 'rake'
+require 'tap/support/gems/rake'
 
 module Tap
   module Tasks

data/lib/tap/test/script_methods.rb

@@ -1,7 +1,7 @@
 require 'test/unit'
 require 'tap/test/file_methods'
 require 'tap/test/subset_methods'
-#require 'tap/support/shell_utils'
+require 'tap/test/script_methods/script_test'
 
 module Test # :nodoc:
   module Unit # :nodoc:
@@ -25,36 +25,15 @@ 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)
+            
+      def assert_output_equal(a, b, 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 ========================
@@ -64,13 +43,12 @@ module Tap
         end
       end
       
-      def assert_alike(a, b, cmd, msg)
+      def assert_alike(a, b, msg)
         if b =~ a
           assert true
         else
           flunk %Q{
 #{msg}
-% #{cmd}
 ================= expected output like ==================
 #{a}
 ======================== but was ========================
@@ -80,58 +58,43 @@ module Tap
         end
       end
       
-      def script_test(test_dir=method_dir(:output))
+      def with_argv(argv=[])
+        current_argv = ARGV.dup
+        begin
+          ARGV.clear
+          ARGV.concat(argv)
+          
+          yield
+          
+        ensure
+          ARGV.clear
+          ARGV.concat(current_argv)
+        end
+      end
+      
+      def default_command_path
+        nil
+      end
+      
+      def script_test(test_dir=method_root)
         subset_test("SCRIPT", "s") do
-          test = CommandTest.new
-          yield(test)
+          cmd = ScriptTest.new(default_command_path)
+          yield(cmd)
           
-          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
+          Tap::Root.indir(test_dir, true) do
+            with_argv do
+              puts "\n# == #{method_name}"
 
-              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
+              cmd.run(env('stepwise')) do |expected, result, msg|
+                case expected
+                when String
+                  assert_output_equal(expected, result, msg)
+                when Regexp
+                  assert_alike(expected, result, msg)
                 end
-              else            
-                puts "%.3fs : %s" % [elapsed, msg]
               end
             end
-          ensure
-            Dir.chdir(current_dir)
-            ARGV.clear
-            ARGV.concat(current_argv)
           end
-          
         end
       end
       

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

@@ -0,0 +1,98 @@
+require 'tap/support/shell_utils'
+
+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
+
+        def initialize(command_path=nil)
+          @command_path = command_path
+          @commands = []
+        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, &validation)
+          new_commands = split(command) 
+          new_commands.each_with_index do |(cmd, expected), i|
+            commands << [cmd, (new_commands.length > 1 ? "#{msg} (#{i})" : msg), expected, validation]
+          end
+        end
+
+        def match(msg, command, regexp=nil, &validation)
+          new_commands = split(command) 
+          new_commands.each_with_index do |(cmd, expected), i|
+            raise "expected text specified in match command" unless expected == nil
+            commands << [cmd, (new_commands.length > 1 ? "#{msg} (#{i})" : msg), regexp, validation]
+          end
+        end
+        
+        def run(stepwise=false)
+          commands.each do |cmd, msg, expected, validation|
+            start = Time.now
+            result = capture_sh(cmd) {|ok, status, tempfile_path| }
+            elapsed = Time.now - start
+
+            yield(expected, result, %Q{#{msg}\n% #{cmd}}) if expected
+            validation.call(result) if validation
+
+            if stepwise
+              print %Q{
+------------------------------------
+%s
+> %s
+%s
+Time Elapsed: %.3fs} % [msg, cmd, result, elapsed]
+
+              print "\nContinue? (y/n): "
+              break if gets.strip =~ /^no?$/i
+            else            
+              puts "%.3fs : %s" % [elapsed, msg]
+            end
+          end
+        end
+      
+        # Returns the command path.
+        def to_s
+          command_path
+        end
+      end
+    end
+  end
+end