bahuvrihi-tap 0.10.1 → 0.10.2

data/History

@@ -1,3 +1,12 @@
+== 0.10.1 / 2008-08-21
+
+Update of Tap with a few improvements to manifests
+and a new manifest command.
+
+* Fixed some bugs and extended manifests
+* Bug fixes in generators
+* Added task definitions to Workflow
+
 == 0.10.0 / 2008-08-08
 
 Major revision.  Reworked configurations and the execution

data/README

@@ -14,6 +14,7 @@ development, and bug tracking.
 * Website[http://tap.rubyforge.org]
 * Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/9908-tap-task-application/overview]
 * Github[http://github.com/bahuvrihi/tap/tree/master]
+* {Google Group}[http://groups.google.com/group/ruby-on-tap]
 
 === Additional Notes:
 

data/bin/tap

@@ -58,7 +58,7 @@ end
 
 begin
   env.activate
-  env.run do
+  env.launch(ARGV) do
     # give some help
     require 'tap/support/command_line'
     

data/cmd/run.rb

@@ -7,7 +7,6 @@
 
 env = Tap::Env.instance
 app = Tap::App.instance
-cmdline = Tap::Support::CommandLine
 
 #
 # handle options
@@ -15,6 +14,7 @@ cmdline = Tap::Support::CommandLine
 
 dump = false
 OptionParser.new do |opts|
+  cmdline = Tap::Support::CommandLine
   
   opts.separator ""
   opts.separator "configurations:"
@@ -48,30 +48,9 @@ end.parse!(ARGV)
 # handle options for each specified task
 #
 
-rounds = cmdline.split(ARGV).collect do |argvs|
-  argvs.each do |argv|
-    ARGV.clear  
-    ARGV.concat(argv)
-   
-    unless td = cmdline.shift(ARGV)
-      # warn nil?
-      next
-    end
-
-    # attempt lookup the task class
-    const = env.search(:tasks, td) or raise "unknown task: #{td}"
-    task_class = const.constantize or raise "unknown task: #{td}"
-    
-    # now let the class handle the argv
-    task, argv = task_class.instantiate(ARGV, app)
-    task.enq *argv.collect! {|str| cmdline.parse_yaml(str) }
-  end
-
-  app.queue.clear
-end
+rounds = env.parse(ARGV)
 ARGV.clear
 
-rounds.delete_if {|round| round.empty? }
 if rounds.empty?
   puts "no task specified"
   exit

data/lib/tap/constants.rb

@@ -1,7 +1,7 @@
 module Tap
   MAJOR = 0
   MINOR = 10
-  TINY = 1
+  TINY = 2
   
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}" 
   WEBSITE="http://tap.rubyforge.org"

data/lib/tap/exe.rb

@@ -1,5 +1,8 @@
+require 'tap/support/command_line/parser'
+
 module Tap
   class Exe < Env
+    Parser = Support::CommandLine::Parser
     
     class << self
       def instantiate
@@ -28,18 +31,22 @@ module Tap
     config :before, nil
     config :after, nil
     config :aliases, {}, &c.hash_or_nil
-    
-    def handle_error(err)
-      case
-      when $DEBUG
-        puts err.message
-        puts
-        puts err.backtrace
-      else puts err.message
-      end
-    end
     
-    def run(argv=ARGV)
+    def app
+      root
+    end
+    
+    def handle_error(err)
+      case
+      when $DEBUG
+        puts err.message
+        puts
+        puts err.backtrace
+      else puts err.message
+      end
+    end
+    
+    def launch(argv=ARGV)
       command = argv.shift.to_s
       
       if aliases && aliases.has_key?(command)
@@ -59,5 +66,58 @@ module Tap
         end
       end
     end
+    
+    def parse(argv=ARGV)
+      parser = Parser.new(argv)
+      targets = parser.targets
+
+      tasks = []
+      rounds = parser.rounds.collect do |round|
+        round.each do |argv|
+          unless td = Parser.shift_arg(argv)
+            # warn nil?
+            next
+          end
+
+          # attempt lookup the task class
+          const = search(:tasks, td) or raise ArgumentError, "unknown task: #{td}"
+          task_class = const.constantize or raise ArgumentError, "unknown task: #{td}"
+
+          # now let the class handle the argv
+          task, args = task_class.instantiate(argv, app)
+          
+          if !targets.include?(tasks.length)
+            task.enq(*args) 
+          elsif !args.empty?
+            raise ArgumentError, "workflow target receives argv: [#{argv.unshift(td).join(', ')}]" 
+          end
+          
+          tasks << task
+        end
+        
+        app.queue.clear
+      end
+      rounds.delete_if {|round| round.empty? }
+      
+      # build the workflow
+      
+      parser.sequences.each do |sequence|
+        app.sequence(*sequence.collect {|s| tasks[s]})
+      end
+      
+      parser.forks.each do |source, targets|
+        app.fork(tasks[source], *targets.collect {|t| tasks[t]})
+      end
+      
+      parser.merges.each do |target, sources|
+        app.merge(tasks[target], *sources.collect {|s| tasks[s]})
+      end
+      
+      parser.sync_merges.each do |target, sources|
+        app.sync_merge(tasks[target], *sources.collect {|s| tasks[s]})
+      end
+      
+      rounds
+    end
   end
 end

data/lib/tap/root.rb

@@ -78,6 +78,19 @@ module Tap
         # as in: relative_filepath('/path', '/path') then the first arg returns nil, and an 
         # empty string is returned
         expanded_path[( expanded_dir.chomp("/").length + 1)..-1] || ""
+      end
+      
+      # Generates a target filepath translated from the source_dir to 
+      # the target_dir. Raises an error if the filepath is not relative 
+      # to the source_dir.    
+      #
+      #    Root.translate("/path/to/file.txt", "/path", "/another/path")  # => '/another/path/to/file.txt'
+      #
+      def translate(path, source_dir, target_dir)
+        unless relative_path = relative_filepath(source_dir, path)
+          raise ArgumentError, "\n#{path}\nis not relative to:\n#{source_dir}"
+        end
+        File.join(target_dir, relative_path)
       end
     
       # Lists all unique paths matching the input glob patterns.  
@@ -109,10 +122,10 @@ module Tap
         end.flatten.uniq
       end
       
-      # Executes the block in the specified directory.  Makes the directory, if
-      # necessary when mkdir is specified.  Otherwise, indir raises an error 
-      # for non-existant directories, as well as non-directory inputs.
-      def indir(dir, mkdir=false)
+      # Like Dir.chdir but makes the directory, if necessary, when 
+      # mkdir is specified. chdir raises an error for non-existant 
+      # directories, as well as non-directory inputs.
+      def chdir(dir, mkdir=false, &block)
         unless File.directory?(dir)
           if !File.exists?(dir) && mkdir
             FileUtils.mkdir_p(dir)
@@ -120,14 +133,8 @@ module Tap
             raise "not a directory: #{dir}"
           end
         end
-
-        pwd = Dir.pwd
-        begin
-          Dir.chdir(dir)
-          yield
-        ensure
-          Dir.chdir(pwd)
-        end
+        
+        Dir.chdir(dir, &block)
       end
       
       # The path root type indicating windows, *nix, or some unknown
@@ -527,17 +534,14 @@ module Tap
       Root.relative_filepath(self[dir], filepath)
     end
   
-    # Generates a target filepath translated from the aliased input dir to 
-    # the aliased output dir. Raises an error if the filepath is not relative 
-    # to the aliased input dir.
+    # Generates a target filepath translated from the aliased source_dir to 
+    # the aliased target_dir. Raises an error if the filepath is not relative 
+    # to the aliased source_dir.
     # 
     #  fp = r.filepath(:in, 'path/to/file.txt')    # => '/root_dir/in/path/to/file.txt'
     #  r.translate(fp, :in, :out)                  # => '/root_dir/out/path/to/file.txt'
-    def translate(filepath, input_dir, output_dir)
-      unless relative_path = relative_filepath(input_dir, filepath)
-        raise "\n#{filepath}\nis not relative to:\n#{input_dir}"
-      end
-      filepath(output_dir, relative_path)
+    def translate(filepath, source_dir, target_dir)
+      Root.translate(filepath, self[source_dir], self[target_dir])
     end
   
     # Lists all files in the aliased dir matching the input patterns.  Patterns 
@@ -555,9 +559,9 @@ module Tap
       Root.vglob(filepath(dir, filename), *vpatterns)
     end
     
-    # Executes the provided block in the specified directory using Root.indir.
-    def indir(dir, mkdir=false)
-      Root.indir(self[dir], mkdir) { yield }
+    # chdirs to the specified directory using Root.chdir.
+    def chdir(dir, mkdir=false, &block)
+      Root.chdir(self[dir], mkdir, &block)
     end
     
     private

data/lib/tap/spec.rb

@@ -0,0 +1,67 @@
+module Tap
+  module Spec
+    
+    def self.included(base)
+      super
+      base.send(:include, Tap::Spec::Adapter)
+    end
+    
+    # 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
+    # and the directories {:input => 'input', :output => 'output', :expected => 'expected'} 
+    # will be used.
+    #
+    # Note: file_test_root determines a root directory <em>based on the calling file</em>.  
+    # 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_file_spec(options={})
+      include Tap::Spec::FileMethods
+      
+      options = {
+        :root => file_test_root,
+        :directories => {:input => 'input', :output => 'output', :expected => 'expected'}
+      }.merge(options)
+      self.trs = 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::SubsetMethods
+    # - inclusion of Tap::Test::InstanceMethods 
+    #
+    # Note:  Unless otherwise specified, <tt>acts_as_tap_test</tt> infers a root directory
+    # 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_spec(options={})
+    #   include Tap::Test::SubsetMethods
+    #   include Tap::Test::FileMethods
+    #   include Tap::Test::TapMethods
+    #   
+    #   acts_as_file_test({:root => file_test_root}.merge(options))
+    # end
+    # 
+    # def acts_as_script_spec(options={})
+    #   include Tap::Test::FileMethods
+    #   include Tap::Test::ScriptMethods
+    #   
+    #   acts_as_file_test({:root => file_test_root}.merge(options))
+    # end
+  end
+end
+
+module Tap
+  
+  # Modules facilitating testing.  TapMethods are specific to
+  # Tap, but SubsetMethods and FileMethods are more general in 
+  # their utility.
+  module Spec
+    autoload(:SubsetMethods, 'tap/spec/subset_methods')
+    autoload(:FileMethods, 'tap/spec/file_methods')
+    autoload(:TapMethods, 'tap/spec/tap_methods')
+  end
+end
+
+
+
+

data/lib/tap/spec/adapter.rb

@@ -0,0 +1,48 @@
+module Tap
+  module Spec
+    module Adapter
+      def method_name
+        self.description.strip.gsub(/\s+/, "_")
+      end
+      
+      # A method serving as the dumping ground for 'should ==' statements
+      # that otherwise cause a 'useless use of <method> in void context' 
+      # warning. Useful if you're running tests with -w.
+      #
+      #   check 1.should == 1
+      #
+      # Check will validate that the line calling check contains a 
+      # should/should_not statement; the check fails if it does not.
+      def check(return_value)
+        return false unless SCRIPT_LINES__
+        
+        caller[0] =~ /^(([A-z]:)?[^:]+):(\d+)/
+
+        check_file = SCRIPT_LINES__[$1]
+        violated("could not validate check: #{$1} (#{$3})") unless check_file 
+
+        # note the line number in caller 
+        # starts at 1, not 0
+        line = check_file[$3.to_i - 1]
+        case line
+        when /\.should(_not)?[^\w]/ 
+          true # pass
+        when /^\s+check/
+          violated("check used without should/should_not statement: #{line} (#{caller[0]})")
+        else
+          violated("multiline check statements are not allowed: #{caller[0]}")
+        end
+      end
+      
+      # Maps flunk to violated.
+      def flunk(msg)
+        violated(msg)
+      end
+      
+      # Maps assert_equal to actual.should == expected.
+      def assert_equal(expected, actual, msg=nil)
+        check actual.should == expected
+      end
+    end
+  end
+end

data/lib/tap/spec/file_methods.rb

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,14 @@
+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/command_line.rb

@@ -7,49 +7,6 @@ module Tap
     module CommandLine
       module_function
 
-      # 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
-      
-      SPLIT_ARGV_REGEXP = /\A-{2}(\+*)\z/
-      
-      def split(argv)
-        current = []
-        current_split = []
-        splits = [current_split]
-
-        argv.each do |arg|
-          if arg =~ SPLIT_ARGV_REGEXP
-            current_split << current  unless current.empty?
-            current = []
-            current_split = (splits[$1.length] ||= [])
-          else
-            current << arg
-          end
-        end
-
-        current_split << current unless current.empty?
-        splits.delete_if {|split| split.nil? || split.empty? }
-        splits
-      end
-
-      def shift(argv)
-        index = nil
-        argv.each_with_index do |arg, i|
-          if arg !~ /\A-/
-            index = i 
-            break
-          end
-        end
-        index == nil ? nil : argv.delete_at(index)
-      end
-
       def usage(path, cols=80)
         parse_usage(File.read(path), cols)
       end