bahuvrihi-tap 0.10.5 → 0.10.6

data/bin/rap

@@ -5,7 +5,18 @@ require "#{File.dirname(__FILE__)}/../lib/tap.rb"
 
 # setup the environment
 begin
+  
+  # handle super options
+  $DEBUG = true if ARGV.delete('-d-')
   env = Tap::Exe.instantiate
+  
+  # add the DEFAULT_TASK_FILE if it exists
+  task_file = File.expand_path('tapfile.rb')
+  if File.exists?(task_file)
+    env.requires.unshift(task_file)
+    env.manifest(:tasks).search_paths << [Dir.pwd, task_file]
+  end
+  
 rescue(Tap::Env::ConfigError)
   # catch errors and exit gracefully
   # (errors usu from gem loading errors)
@@ -13,31 +24,6 @@ rescue(Tap::Env::ConfigError)
   exit(1)
 end
 
-# parse super options
-require 'tap/support/super_optparse'
-Tap::Support::SuperOptionParser.new do |opts|
-  opts.on("-e", "--env [CONFIG:VALUE]", "set an env configuration") do |arg|
-    config, value = arg.split(":", 2)
-    env.config[config.to_sym] = value
-  end
-  
-  opts.on("-a", "--app [CONFIG:VALUE]", "set an app configuration") do |arg|
-    config, value = arg.split(":", 2)
-    env.app.config[config.to_sym] = value
-  end
-  
-  opts.on("-d", "set $DEBUG to true") do
-    $DEBUG = true
-  end
-end.parse!
-
-# add the DEFAULT_TASK_FILE if it exists
-task_file = File.expand_path('tapfile.rb')
-if File.exists?(task_file)
-  env.requires.unshift(task_file)
-  env.manifest(:tasks).search_paths << [Dir.pwd, task_file]
-end
-
 #
 # setup after script
 #

data/bin/tap

@@ -14,7 +14,11 @@ require "#{File.dirname(__FILE__)}/../lib/tap.rb"
 
 # setup the environment
 begin
+  
+  # handle super options
+  $DEBUG = true if ARGV.delete('-d-')
   env = Tap::Exe.instantiate
+  
 rescue(Tap::Env::ConfigError)
   # catch errors and exit gracefully
   # (errors usu from gem loading errors)
@@ -22,24 +26,6 @@ rescue(Tap::Env::ConfigError)
   exit(1)
 end
 
-# parse super options
-require 'tap/support/super_optparse'
-Tap::Support::SuperOptionParser.new do |opts|
-  opts.on("-e", "--env [CONFIG:VALUE]", "set an env configuration") do |arg|
-    config, value = arg.split(":", 2)
-    env.config[config.to_sym] = value
-  end
-  
-  opts.on("-a", "--app [CONFIG:VALUE]", "set an app configuration") do |arg|
-    config, value = arg.split(":", 2)
-    env.app.config[config.to_sym] = value
-  end
-  
-  opts.on("-d", "set $DEBUG to true") do
-    $DEBUG = true
-  end
-end.parse!
-
 #
 # setup after script
 #

data/lib/tap.rb

@@ -1,4 +1,4 @@
-require 'yaml'                   # expensive to load
+autoload(:YAML, 'yaml')                   # expensive to load
 
 # Apply version-specific patches
 case RUBY_VERSION

data/lib/tap/constants.rb

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

data/lib/tap/exe.rb

@@ -8,7 +8,7 @@ module Tap
     class << self
       def instantiate(path=Dir.pwd, logger=Tap::App::DEFAULT_LOGGER, &block)
         app = Tap::App.instance = Tap::App.new({:root => path}, logger)
-        exe = super(app, load_config(GLOBAL_CONFIG_FILE), app.logger)
+        exe = super(app, load_config(GLOBAL_CONFIG_FILE), app.logger, &block)
         
         # add all gems if no gems are specified (Note this is VERY SLOW ~ 1/3 the overhead for tap)
         if !File.exists?(Tap::Env::DEFAULT_CONFIG_FILE)

data/lib/tap/generator/generators/file_task/templates/task.erb

@@ -25,7 +25,7 @@ class <%= const.const_name %> < Tap::FileTask
     end
 
     File.open(target, "wb") do |file|
-      file << letter_count.to_yaml
+      file << YAML.dump(letter_count)
     end
 
     target

data/lib/tap/parser.rb

@@ -48,6 +48,15 @@ module Tap
         /\A(--)?(\d*)#{Regexp.escape(l)}([\d,]*)#{Regexp.escape(r)}\z/
       end
       
+      # The escape begin argument
+      ESCAPE_BEGIN = "-."
+      
+      # The escape end argument
+      ESCAPE_END = ".-"
+      
+      # The parser end flag
+      END_FLAG = "---"
+      
       # Matches any breaking arg (ex: '--', '--+', '--1:2')
       BREAK =  /\A--(\z|[\+\d\:\*\[\{\(])/
         
@@ -181,21 +190,26 @@ module Tap
     # An array of task declarations.
     attr_reader :tasks
     
-    # The internal rounds data; an array of integers signifying the
-    # round a task should be assigned to, at a given index.
-    attr_reader :round_indicies
+    # An array of integers indicating which tasks
+    # should be set as globals.
+    attr_reader :globals
+    
+    # The internal rounds data; an array of integers mapping to tasks
+    # by index.  The integers signify the round the corresponding
+    # task should be assigned to; a nil entry indicates the task
+    # should not be enqued to a round.
+    attr_reader :rounds_map
     
     # The internal workflow data; an array of [type, targets] pairs 
-    # signifying the workflow type and targets assigned to the task 
-    # at a given index.  Differs from the return from workflow in
-    # that reversed-workflows (ex merge, sync_merge) will be organized
-    # by target rather than by source.
-    attr_reader :workflows
+    # mapping to tasks by index.  The entries signify the workflow 
+    # type and targets assigned to the corresponding task.
+    attr_reader :workflow_map
     
     def initialize(argv=nil)
       @tasks = []
-      @round_indicies = []
-      @workflows = []
+      @globals = []
+      @rounds_map = []
+      @workflow_map = []
       
       case argv
       when String, Array 
@@ -206,11 +220,85 @@ module Tap
     # Iterates through the argv splitting out task and workflow definitions.
     # Task definitions are split out (with configurations) along round and/or
     # workflow break lines.  Rounds and workflows are dynamically parsed;
-    # tasks may be reassigned to rounds, or have their workflow reassigned
-    # by later arguments, perhaps in later calls to parse.
+    # tasks may be reassigned to different rounds or workflows by later 
+    # arguments.
     #
-    # === Examples
+    # Parse is non-destructive to argv.  If a string argv is provided, parse
+    # splits it into an array using Shellwords.
+    #
+    # ==== Round Assignment
+    # Tasks can be defined and set to a round using the following:
+    #
+    #   break           assigns task(s)         to round
+    #   --              next                    0
+    #   --+             next                    1
+    #   --++            next                    2
+    #   --+2            next                    2
+    #   --+2[1,2,3]     1,2,3                   2
+    #
+    # Here all task (except c) are parsed into round 0, then the
+    # final argument reassigns e to round 3.
+    #
+    #   p = Parser.new "a -- b --+ c -- d -- e --+3[4]"
+    #   p.rounds                   # => [[0,1,3],[2], nil, [4]]
+    #
+    # ==== Workflow Assignment
+    # All simple workflow patterns except switch can be specified within
+    # the parse syntax (switch is the exception because there is no good
+    # way to define a block from an array).  
+    #
+    #   break      pattern       source(s)      target(s)
+    #   --:        sequence      last           next
+    #   --[]       fork          last           next
+    #   --{}       merge         next           last
+    #   --()       sync_merge    next           last
+    #
+    #   example       meaning
+    #   --1:2         1.sequence(2)
+    #   --1:2:3       1.sequence(2,3)
+    #   --:2:         last.sequence(2,next)
+    #   --[]          last.fork(next)
+    #   --1{2,3,4}    1.merge(2,3,4)
+    #   --(2,3,4)     last.sync_merge(2,3,4)
     #
+    # Note how all of the bracketed styles behave similarly; they are
+    # parsed with essentially the same code, only reversing the source
+    # and target in the case of merges.
+    #
+    # Here a and b are sequenced inline.  Task c is assigned to no 
+    # workflow until the final argument which sequenced b and c.
+    #
+    #   p = Parser.new "a --: b -- c --1:2"
+    #   p.tasks                    # => [["a"], ["b"], ["c"]]
+    #   p.workflow(:sequence)      # => [[0,1],[1,2]]
+    #
+    # ==== Globals
+    # Global instances of task (used, for example, by dependencies) may
+    # be assigned in the parse syntax as well.  The break for a global
+    # is '--*'.
+    #
+    #   p = Parser.new "a -- b --* global_name --config for --global"
+    #   p.globals                  # => [2]
+    #
+    # ==== Escapes and End Flags
+    # Breaks can be escaped by enclosing them in '-.' and '.-' delimiters;
+    # any number of arguments may be enclosed within the escape. After the 
+    # end delimiter, breaks are active once again.
+    #
+    #   p = Parser.new "a -- b -- c"
+    #   p.tasks                    # => [["a"], ["b"], ["c"]]
+    # 
+    #   p = Parser.new "a -. -- b .- -- c"
+    #   p.tasks                    # => [["a", "--", "b"], ["c"]]
+    #
+    # Parsing continues until the end of argv, or a an end flag '---' is 
+    # reached.  The end flag may also be escaped.
+    #
+    #   p = Parser.new "a -- b --- c"
+    #   p.tasks                    # => [["a"], ["b"]]
+    #
+    #--
+    # === Examples
     # Parse two tasks, with inputs and configs at separate times.  Both 
     # are assigned to round 0.
     #
@@ -249,7 +337,7 @@ module Tap
     # using Shellwords):
     #
     #   p = Parser.new "a --: b --: c --: d"
-    #   p.tasks                    # => [["a"], ["b"], ["c"], ["d"]]
+    #   p.tasks                   # => [["a"], ["b"], ["c"], ["d"]]
     #   p.workflow(:sequence)     # => [[0,1],[1,2],[2,3]]
     #
     #   p.parse "1[2,3]"
@@ -257,19 +345,62 @@ module Tap
     #   p.workflow(:fork)         # => [[1,[2,3]]]
     #
     #   p.parse "e --{2,3}"
-    #   p.tasks                    # => [["a"], ["b"], ["c"], ["d"], ["e"]]
+    #   p.tasks                   # => [["a"], ["b"], ["c"], ["d"], ["e"]]
     #   p.workflow(:sequence)     # => [[0,1]]
     #   p.workflow(:fork)         # => [[1,[2,3]]]
     #   p.workflow(:merge)        # => [[4,[2,3]]]
     #
+    # Use escapes ('-.' and '.-') to bring breaks into a task array.  Any
+    # number of breaks/args may occur within an escape sequence; breaks
+    # are re-activated after the stop-escape:
+    #
+    #   p = Parser.new "a -. -- b -- .- c -- d"
+    #   p.tasks                   # => [["a", "--", "b", "--", "c"], ["d"]]
+    #
+    # Use the stop delimiter to stop parsing (the unparsed argv is 
+    # returned by parse):
+    #
+    #   argv = ["a", "--", "b", "---", "args", "after", "stop"]
+    #   p = Parser.new
+    #   p.parse(argv)             # => ["args", "after", "stop"]
+    #   p.tasks                   # => [["a"], ["b"]]
+    #
     def parse(argv)
+      parse!(argv.kind_of?(String) ? argv : argv.dup)
+    end
+    
+    # Same as parse, but removes parsed args from argv.
+    def parse!(argv)
       if argv.kind_of?(String)
         argv = Shellwords.shellwords(argv)
       end
       
-      current_round_index = @round_indicies[next_index]
+      round_index = 0
       current = []
-      argv.each do |arg|
+      escape = false
+      while !argv.empty?
+        arg = argv.shift
+        
+        # add escaped arguments
+        if escape
+          if arg == ESCAPE_END
+            escape = false
+          else
+            current << arg
+          end
+          
+          next
+        end
+        
+        # begin escaping if necessary
+        if arg == ESCAPE_BEGIN
+          escape = true
+          next
+        end
+        
+        # break if the end flag is reached
+        break if arg == END_FLAG
+
         # add all non-breaking args to the
         # current argv array.  this should
         # include all lookups, inputs, and
@@ -282,7 +413,8 @@ module Tap
         # unless the current argv is empty,
         # append and start a new argv
         unless current.empty?
-          current_round_index = add_task(current, current_round_index)
+          add_task(current, round_index)
+          round_index = 0
           current = []
         end
         
@@ -290,32 +422,36 @@ module Tap
         # and add to the appropriate collection
         case arg
         when ROUND
-          current_round_index, indicies = parse_round($3, $6)
-          indicies.each {|index| @round_indicies[index] = current_round_index }
-
+          round_index, indicies = parse_round($3, $6)
+          indicies.each {|index| rounds_map[index] = round_index }
+          next
+          
         when SEQUENCE   
           indicies = parse_sequence($2)
           while indicies.length > 1
-            source_index = indicies.shift
-            set_workflow(:sequence, source_index, indicies[0])
+            set_workflow(:sequence, indicies.shift, indicies[0])
           end
           
-        # when INSTANCE   then @instances << parse_instance($2)
+        when INSTANCE    then globals << parse_instance($2)
         when FORK        then set_workflow(:fork, *parse_bracket($2, $3))
         when MERGE       then set_reverse_workflow(:merge, *parse_bracket($2, $3))
         when SYNC_MERGE  then set_reverse_workflow(:sync_merge, *parse_bracket($2, $3))
         else raise ArgumentError, "invalid break argument: #{arg}"
         end
+        
+        round_index = nil
       end
       
       unless current.empty?
-        add_task(current, current_round_index)
+        add_task(current, round_index)
       end
+      
+      argv
     end
     
     # Returns an array of [type, targets] objects; the index of
     # each entry corresponds to the task on which to build the
-    # workflow of the specified type.  
+    # workflow.
     #
     # If a type is specified, the output is ordered differently;
     # The return is an array of [source, targets] for the 
@@ -326,7 +462,7 @@ module Tap
       # recollect reverse types
       
       workflows = []
-      @workflows.each_with_index do |entry, source|
+      workflow_map.each_with_index do |entry, source|
         next if entry == nil
         
         workflows[source] = case entry[0]
@@ -353,7 +489,7 @@ module Tap
     #
     def rounds
       collected_rounds = []
-      @round_indicies.each_with_index do |round_index, index|
+      @rounds_map.each_with_index do |round_index, index|
         (collected_rounds[round_index] ||= []) << index unless round_index == nil
       end
       
@@ -379,11 +515,18 @@ module Tap
     end
     
     def build(app)
-      # attempt lookup and instantiation of the task classes
-      # note that instances is actually an array of [instance, args]
-      # pairs, where the instance will be enqued with the args
-      instances = tasks.collect do |args|
-        yield(args)
+      instances = []
+      
+      # instantiate and assign globals
+      globals.each do |index|
+        task, args = yield(tasks[index])
+        task.class.instance = task
+        instances[index] = [task, args]
+      end
+      
+      # instantiate the remaining task classes
+      tasks.each_with_index do |args, index|
+        instances[index] ||= yield(args)
       end
 
       # build the workflow
@@ -403,12 +546,19 @@ module Tap
       queues = rounds.collect do |round|
         round.each do |index|
           task, args = instances[index]
+          instances[index] = nil
           task.enq(*args)
         end
 
         app.queue.clear
       end
       queues.delete_if {|queue| queue.empty? }
+      
+      # notify any args that will be overlooked
+      instances.compact.each do |(instance, args)|
+        next if args.empty?
+        puts "ignoring args: #{instance} [#{args.join(' ')}]"
+      end
 
       queues
     end
@@ -425,11 +575,11 @@ module Tap
       tasks.length - 1
     end
     
-    # Sets the targets to the source in workflows, tracking the
+    # Sets the targets to the source in workflow_map, tracking the
     # workflow type.
     def set_workflow(type, source, targets) # :nodoc
-      # warn if workflows[source] is already set
-      @workflows[source] = [type, targets]
+      workflow_map[source] = [type, targets]
+      [*targets].each {|target| rounds_map[target] = nil }
     end
     
     # Sets a reverse workflow... ie the source is set to
@@ -438,10 +588,9 @@ module Tap
       targets.each {|target| set_workflow(type, target, source) }
     end
     
-    def add_task(definition, round_index=@round_indicies[next_index]) # :nodoc
-      @tasks << definition
-      @round_indicies[current_index] = (round_index || 0)
-      @round_indicies[next_index]
+    def add_task(definition, round_index) # :nodoc
+      tasks << definition
+      rounds_map[current_index] = round_index
     end
     
     # Yields each round formatted as a string.

data/lib/tap/support/configurable_class.rb

@@ -88,8 +88,8 @@ module Tap
       # Loads the contents of path as YAML.  Returns an empty hash if the path 
       # is empty, does not exist, or is not a file.
       def load_config(path)
-        return {} if path == nil || !File.file?(path)
-
+        # the last check prevents YAML from auto-loading itself for empty files
+        return {} if path == nil || !File.file?(path) || File.size(path) == 0
         YAML.load_file(path) || {}
       end
       

data/lib/tap/support/gems/rack.rb

@@ -1,5 +1,6 @@
 require 'rack'
 require 'cgi'
+require 'yaml'
 
 module Tap
   module Support

data/lib/tap/support/templater.rb

@@ -65,7 +65,7 @@ module Tap
       	#   {'key' => 'value'}.to_yaml           # => "--- \nkey: value\n"
       	#   yamlize {'key' => 'value'}           # => "key: value"
         def yamlize(object)
-          object == nil ? "~" : object.to_yaml[4...-1].strip
+          object == nil ? "~" : YAML.dump(object)[4...-1].strip
         end
         
         # Nest the return of the block in the nesting lines.

data/lib/tap/task.rb

@@ -180,6 +180,10 @@ module Tap
         super
       end
       
+      #--
+      # use with caution... should reset dependencies?
+      attr_writer :instance
+      
       # Returns an instance of self; the instance is a kind of 'global'
       # instance used in class-level dependencies.  See depends_on.
       def instance

data/lib/tap/test/script_methods.rb

@@ -47,14 +47,11 @@ module Tap
       
       def script_test(test_dir=method_root.root)
         subset_test("SCRIPT", "s") do
-          cmd = ScriptTest.new(default_command_path)
-          yield(cmd)
-          
-          Tap::Root.chdir(test_dir, true) do
+          Tap::Root.chdir(test_dir, true) do  
             Utils.with_argv do
               puts "\n# == #{method_name}"
 
-              cmd.run(env('stepwise')) do |expected, result, msg|
+              cmd = ScriptTest.new(default_command_path, env('stepwise')) do |expected, result, msg|
                 case expected
                 when String
                   assert_output_equal(expected, result, msg)
@@ -62,6 +59,8 @@ module Tap
                   assert_alike(expected, result, msg)
                 end
               end
+              
+              yield(cmd)
             end
           end
         end

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

@@ -62,12 +62,14 @@ module Tap
               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).flatten.join
+            
+            splits.zip(substituents).to_a.flatten.join
           end
           
           # Same as escape.

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

@@ -13,10 +13,14 @@ module Tap
         # An array of (command, message, expected, validation)
         # entries, representing the accumulated test commands.
         attr_reader :commands
-
-        def initialize(command_path=nil)
+        
+        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
@@ -50,28 +54,33 @@ module Tap
         end
         
         def check(msg, command, use_regexp_escapes=true, &validation)
-          new_commands = split(command) 
-          new_commands.each_with_index do |(cmd, expected), i|
+          new_commands = split(command)
+          commands = new_commands.collect do |cmd, expected|
             expected = RegexpEscape.new(expected) if expected && use_regexp_escapes
-            commands << [cmd, (new_commands.length > 1 ? "#{msg} (#{i})" : msg), expected, validation]
+            [cmd, msg, expected, validation]
           end
+          
+          run(commands)
         end
 
         def match(msg, command, regexp=nil, &validation)
-          new_commands = split(command) 
-          new_commands.each_with_index do |(cmd, expected), i|
+          new_commands = split(command)
+          commands = new_commands.collect do |cmd, expected|
             raise "expected text specified in match command" unless expected == nil
-            commands << [cmd, (new_commands.length > 1 ? "#{msg} (#{i})" : msg), regexp, validation]
+            [cmd, msg, regexp, validation]
           end
+          
+          run(commands)
         end
         
-        def run(stepwise=false)
-          commands.each do |cmd, msg, expected, validation|
+        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
-
-            yield(expected, result, %Q{#{msg}\n% #{cmd}}) if expected
+            
+            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
@@ -80,12 +89,12 @@ module Tap
 %s
 > %s
 %s
-Time Elapsed: %.3fs} % [msg, cmd, result, elapsed]
+Time Elapsed: %.3fs} % [cmd_msg, cmd, result, elapsed]
 
               print "\nContinue? (y/n): "
               break if gets.strip =~ /^no?$/i
-            else            
-              puts "%.3fs : %s" % [elapsed, msg]
+            else
+              puts "%.3fs : %s" % [elapsed, cmd_msg]
             end
           end
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bahuvrihi-tap
 version: !ruby/object:Gem::Version 
-  version: 0.10.5
+  version: 0.10.6
 platform: ruby
 authors: 
 - Simon Chiang