bahuvrihi-tap 0.10.3 → 0.10.4

data/lib/tap/constants.rb

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

data/lib/tap/exe.rb

@@ -1,9 +1,13 @@
+require 'tap/env'
+require 'tap/app'
+require 'tap/parser'
+
 module Tap
   class Exe < Env
 
     class << self
-      def instantiate
-        app = Tap::App.instance
+      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(Tap::Env::GLOBAL_CONFIG_FILE), app.logger)
         
         # add all gems if no gems are specified (Note this is VERY SLOW ~ 1/3 the overhead for tap)
@@ -43,7 +47,7 @@ module Tap
       end
     end
     
-    def launch(argv=ARGV)
+    def execute(argv=ARGV)
       command = argv.shift.to_s
       
       if aliases && aliases.has_key?(command)
@@ -63,5 +67,46 @@ module Tap
         end
       end
     end
+
+    def build(argv=ARGV)
+      parser = Parser.new(argv)
+      
+      # attempt lookup and instantiate the task class
+      tasks = parser.tasks.collect do |args|
+        task = args.shift
+
+        const = search(:tasks, task) or raise ArgumentError, "unknown task: #{task}"
+        task_class = const.constantize or raise ArgumentError, "unknown task: #{task}"
+        task_class.instantiate(args, app)
+      end
+
+      # build the workflow
+      parser.workflow.each_with_index do |(type, target_indicies), source_index|
+        next if type == nil
+        
+        tasks[source_index].send(type, *target_indicies.collect {|i| tasks[i] })
+      end
+
+      # build queues
+      queues = parser.rounds.collect do |round|
+        round.each do |index|
+          task, args = tasks[index]
+          task.enq(*args)
+        end
+
+        app.queue.clear
+      end
+      queues.delete_if {|queue| queue.empty? }
+
+      queues
+    end
+    
+    def run(queues)
+      queues.each_with_index do |queue, i|
+        app.queue.concat(queue)
+        app.run
+      end
+    end
+    
   end
 end

data/lib/tap/generator/base.rb

@@ -60,6 +60,10 @@ module Tap
         raise NotImplementedError
       end
       
+      def prepare(target, options={})
+        raise NotImplementedError
+      end
+      
       def directories(root, targets, options={})
         directory(root)
         targets.each do |target|

data/lib/tap/generator/destroy.rb

@@ -19,8 +19,12 @@ module Tap
           file_task.rmdir(target) unless pretend    
         end
       end
-    
+      
       def file(target, options={})
+        prepare(target, options)
+      end
+      
+      def prepare(target, options={})
         target = File.expand_path(target, target_dir)
         
         if File.exists?(target)
@@ -31,7 +35,7 @@ module Tap
           log_relative :missing, target
         end
       end
+      
     end
-    
   end
 end

data/lib/tap/generator/generate.rb

@@ -17,23 +17,29 @@ module Tap
       end
     
       def file(target, options={})
-        target = File.expand_path(target, target_dir)
-        
-        case
-        when !File.exists?(target)
-          log_relative :create, target
-          # should check for identical...
-        when force_file_collision?(target)
-          log_relative :force, target
-        else
-          log_relative :skip, target
-          return
-        end
-        
-        unless pretend
-          file_task.prepare(target) 
-          File.open(target, "wb") {|file| yield(file) if block_given? }
+        prepare(target, options) do |path|
+          File.open(path, "wb") {|file| yield(file) if block_given? }
         end
+      end
+      
+      def prepare(target, options={})
+        target = File.expand_path(target, target_dir)
+        
+        case
+        when !File.exists?(target)
+          log_relative :create, target
+          # should check for identical...
+        when force_file_collision?(target)
+          log_relative :force, target
+        else
+          log_relative :skip, target
+          return
+        end
+        
+        unless pretend
+          file_task.prepare(target) 
+          yield(target)
+        end
       end
       
       # Ask the user interactively whether to force collision.

data/lib/tap/generator/generators/root/root_generator.rb

@@ -4,7 +4,8 @@ module Tap::Generator::Generators
   
   # :startdoc::generator a basic tap directory structure
   #
-  # Generates a tap root directory structure:
+  # Generates a tap root directory structure.  Use the switches to 
+  # generate a tapfile and/or a tap config file:
   #
   #   root
   #   |- Rakefile
@@ -17,11 +18,10 @@ module Tap::Generator::Generators
   #       |- tap_test_suite.rb
   #       `- tapfile_test.rb
   #
-  # By default a tapfile will be created, but not a config file.
   class RootGenerator < Tap::Generator::Base
     
     config :config_file, false, &c.switch   # create a tap.yml file
-    config :tapfile, true, &c.switch        # create a tapfile
+    config :tapfile, false, &c.switch       # create a tapfile
     
     # ::args ROOT, PROJECT_NAME=basename(ROOT)
     def manifest(m, root, project_name=nil)

data/lib/tap/parser.rb

@@ -0,0 +1,435 @@
+autoload(:Shellwords, 'shellwords')
+
+module Tap
+  class Parser
+    module Utils
+      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
+      
+      # Shell quotes the input string by enclosing in quotes if
+      # str has no quotes, or double quotes if str has no double
+      # quotes.  Returns the str if it has not whitespace, quotes
+      # or double quotes.
+      #
+      # Raises an ArgumentError if str has both quotes and double
+      # quotes.
+      def shell_quote(str)
+        return str unless str =~ /[\s'"]/
+        
+        quote = str.include?("'")
+        double_quote = str.include?('"')
+        
+        case
+        when !quote then "'#{str}'"
+        when !double_quote then "\"#{str}\""
+        else raise ArgumentError, "cannot shell quote: #{str}"
+        end
+      end
+      
+      # Defines a break regexp that matches a bracketed-pairs
+      # break.  The left and right brackets are specified as
+      # inputs.  After a match:
+      #
+      #   $2:: The source string after the break. 
+      #        (ex: '--[]' => '', '--1[]' => '1')
+      #   $3:: The target string, or nil. 
+      #        (ex: '--[]' => '', '--1[1,2,3]' => '1,2,3')
+      #
+      def bracket_regexp(l, r)
+        /\A(--)?(\d*)#{Regexp.escape(l)}([\d,]*)#{Regexp.escape(r)}\z/
+      end
+      
+      # Matches any breaking arg (ex: '--', '--+', '--1:2')
+      BREAK =  /\A--(\z|[\+\d\:\*\[\{\(])/
+        
+      # Matches the start of any workflow regex (ex: '+', '2', '[', '{')
+      WORKFLOW =  /\A[\+\d\:\*\[\{\(]/
+
+      # Matches an execution-round break.  After the match:
+      #
+      #   $3:: The round string after the break, or nil. 
+      #        (ex: '--' => nil, '--++' => '++', '--+1' => '+1')
+      #   $6:: The target string, or nil. 
+      #        (ex: '--+' => nil, '--+[1,2,3]' => '1,2,3')
+      #
+      ROUND = /\A(--\z|(--)?(\+(\d*|\+*))(\[([\d,]*)\])?\z)/
+
+      # Matches a sequence break.  After the match:
+      #
+      #   $2:: The sequence string after the break. 
+      #        (ex: '--:' => ':', '--1:2' => '1:2', '--1:' => '1:', '--:2' => ':2')
+      #
+      SEQUENCE = /\A(--)?(\d*(:\d*)+)\z/
+      
+      # Matches an instance break.  After the match:
+      #
+      #   $2:: The index string after the break.
+      #        (ex: '--*' => '', '--*1' => '1')
+      #
+      INSTANCE = /\A(--)?\*(\d*)\z/
+      
+      # A break regexp using "[]"
+      FORK = bracket_regexp("[", "]")
+      
+      # A break regexp using "{}"
+      MERGE = bracket_regexp("{", "}")
+      
+      # A break regexp using "()"
+      SYNC_MERGE = bracket_regexp("(", ")")
+
+      # Parses an indicies str along commas, and collects the indicies
+      # as integers. Ex:
+      #
+      #   parse_indicies('')            # => []
+      #   parse_indicies('1')           # => [1]
+      #   parse_indicies('1,2,3')       # => [1,2,3]
+      #
+      def parse_indicies(str, regexp=/,+/)
+        indicies = []
+        str.split(regexp).each do |n| 
+          indicies << n.to_i unless n.empty?
+        end
+        indicies
+      end
+
+      # Parses the match of a ROUND regexp into a round index
+      # and an array of task indicies that should be added to the
+      # round. The inputs correspond to $3 and $6 for the match.
+      #
+      # If $3 is nil, a round index of zero is assumed; if $6 is  
+      # nil, then indicies of [] are assumed.
+      #
+      #   parse_round("+", "")          # => [1, []]
+      #   parse_round("+2", "1,2,3")    # => [2, [1,2,3]]
+      #   parse_round(nil, nil)         # => [0, []]
+      #
+      def parse_round(three, six)
+        index = case three
+        when nil then 0
+        when /\d/ then three[1, three.length-1].to_i
+        else three.length
+        end
+        [index, six == nil ? [] : parse_indicies(six)]
+      end
+
+      # Parses the match of a SEQUENCE regexp into an array of task
+      # indicies. The input corresponds to $2 for the match.  The 
+      # current and next index are assumed if $2 starts and/or ends 
+      # with a semi-colon.
+      #
+      #   parse_sequence("1:2:3")       # => [1,2,3]
+      #   parse_sequence(":1:2:")       # => [:current_index,1,2,:next_index]
+      #
+      def parse_sequence(two)
+        seq = parse_indicies(two, /:+/)
+        seq.unshift current_index if two[0] == ?:
+        seq << next_index if two[-1] == ?:
+        seq
+      end
+      
+      # Parses the match of an INSTANCE regexp into an index.
+      # The input corresponds to $2 for the match.  The next 
+      # index is assumed if $2 is empty.
+      #
+      #   parse_instance("1")           # => 1
+      #   parse_instance("")            # => :next_index
+      #
+      def parse_instance(two)
+        two.empty? ? next_index : two.to_i
+      end
+
+      # Parses the match of an bracket_regexp into a [source_index, 
+      # target_indicies] array. The inputs corresponds to $2 and
+      # $3 for the match.  The current and next index are assumed 
+      # if $2 and/or $3 is empty.
+      #
+      #   parse_bracket("1", "2,3")     # => [1, [2,3]]
+      #   parse_bracket("", "")         # => [:current_index, [:next_index]]
+      #   parse_bracket("1", "")        # => [1, [:next_index]]
+      #   parse_bracket("", "2,3")      # => [:current_index, [2,3]]
+      #
+      def parse_bracket(two, three)
+        targets = parse_indicies(three)
+        targets << next_index if targets.empty?
+        [two.empty? ? current_index : two.to_i, targets]
+      end
+    end
+    
+    class << self  
+      def load(task_argv)
+        task_argv = YAML.load(task_argv) if task_argv.kind_of?(String)
+        
+        tasks, argv = task_argv.partition {|obj| obj.kind_of?(Array) }
+        parser = new
+        parser.tasks.concat(tasks)
+        parser.parse(argv)
+        parser
+      end
+    end
+    
+    include Utils
+    
+    # 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
+    
+    # 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
+    
+    def initialize(argv=nil)
+      @tasks = []
+      @round_indicies = []
+      @workflows = []
+      
+      case argv
+      when String, Array 
+        parse(argv)
+      end
+    end
+    
+    # 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.
+    #
+    # === Examples
+    #
+    # Parse two tasks, with inputs and configs at separate times.  Both 
+    # are assigned to round 0.
+    #
+    #   p = Parser.new
+    #   p.parse(["a", "b", "--config", "c"])
+    #   p.tasks          
+    #   # => [
+    #   # ["a", "b", "--config", "c"]]
+    #
+    #   p.parse(["x", "y", "z"])
+    #   p.tasks          
+    #   # => [
+    #   # ["a", "b", "--config", "c"],
+    #   # ["x", "y", "z"]]
+    #   
+    #   p.rounds         # => [[0,1]]
+    #
+    # Parse two simple tasks at the same time into different rounds.
+    #
+    #   p = Parser.new ["a", "--+", "b"]
+    #   p.tasks          # => [["a"], ["b"]]
+    #   p.rounds         # => [[0], [1]]
+    #
+    # Rounds can be declared multiple ways:
+    #
+    #   p = Parser.new ["--+", "a", "--", "b", "--", "c", "--", "d"]
+    #   p.tasks          # => [["a"], ["b"], ["c"], ["d"]]
+    #   p.rounds         # => [[1,2,3], [0]]
+    #
+    #   p.parse ["+3[2,3]"]
+    #   p.rounds         # => [[1], [0], nil, [2,3]]
+    #
+    # Note the rounds were re-assigned using the second parse.  Very
+    # similar things may be done with workflows (note also that this
+    # example shows how parse splits a string input into an argv 
+    # using Shellwords):
+    #
+    #   p = Parser.new "a --: b --: c --: d"
+    #   p.tasks                    # => [["a"], ["b"], ["c"], ["d"]]
+    #   p.workflow(:sequence)     # => [[0,1],[1,2],[2,3]]
+    #
+    #   p.parse "1[2,3]"
+    #   p.workflow(:sequence)     # => [[0,1],[2,3]]
+    #   p.workflow(:fork)         # => [[1,[2,3]]]
+    #
+    #   p.parse "e --{2,3}"
+    #   p.tasks                    # => [["a"], ["b"], ["c"], ["d"], ["e"]]
+    #   p.workflow(:sequence)     # => [[0,1]]
+    #   p.workflow(:fork)         # => [[1,[2,3]]]
+    #   p.workflow(:merge)        # => [[4,[2,3]]]
+    #
+    def parse(argv)
+      if argv.kind_of?(String)
+        argv = Shellwords.shellwords(argv)
+      end
+      
+      current_round_index = @round_indicies[next_index]
+      current = []
+      argv.each do |arg|
+        # add all non-breaking args to the
+        # current argv array.  this should
+        # include all lookups, inputs, and
+        # configurations
+        unless arg =~ BREAK || (current.empty? && arg =~ WORKFLOW)
+          current << arg
+          next  
+        end
+        
+        # unless the current argv is empty,
+        # append and start a new argv
+        unless current.empty?
+          current_round_index = add_task(current, current_round_index)
+          current = []
+        end
+        
+        # determine the type of break, parse, 
+        # 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 }
+
+        when SEQUENCE   
+          indicies = parse_sequence($2)
+          while indicies.length > 1
+            source_index = indicies.shift
+            set_workflow(:sequence, source_index, indicies[0])
+          end
+          
+        # when INSTANCE   then @instances << 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
+      end
+      
+      unless current.empty?
+        add_task(current, current_round_index)
+      end
+    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.  
+    #
+    # If a type is specified, the output is ordered differently;
+    # The return is an array of [source, targets] for the 
+    # specified workflow type.  In this case the order of the
+    # returned array is meaningless.
+    #
+    def workflow(type=nil)
+      # recollect reverse types
+      
+      workflows = []
+      @workflows.each_with_index do |entry, source|
+        next if entry == nil
+        
+        workflows[source] = case entry[0]
+        when :merge, :sync_merge
+          workflow_type, target = entry
+          (workflows[target] ||= [workflow_type, []])[1] << source
+          nil
+        else entry
+        end
+      end
+      
+      return workflows if type == nil
+      
+      declarations = []
+      workflows.each_with_index do |(workflow_type, targets), source|
+        declarations << [source, targets] if workflow_type == type
+      end
+      
+      declarations
+    end
+    
+    # Returns an array task indicies; the index of each entry
+    # corresponds to the round the tasks should be assigned to.
+    #
+    def rounds
+      collected_rounds = []
+      @round_indicies.each_with_index do |round_index, index|
+        (collected_rounds[round_index] ||= []) << index unless round_index == nil
+      end
+      
+      collected_rounds.each {|round| round.uniq! unless round.nil? }
+    end
+    
+    def to_s
+      segments = tasks.collect do |argv| 
+        argv.collect {|arg| shell_quote(arg) }.join(' ')
+      end
+      each_round_str {|str| segments << str }
+      each_workflow_str {|str| segments << str }
+      
+      segments.join(" -- ")
+    end
+    
+    def dump
+      segments = tasks.dup
+      each_round_str {|str| segments << str }
+      each_workflow_str {|str| segments << str }
+
+      segments
+    end
+    
+    protected
+    
+    # Returns the index of the next argv to be parsed.
+    def next_index
+      tasks.length
+    end
+    
+    # Returns the index of the last argv parsed.
+    def current_index
+      tasks.length - 1
+    end
+    
+    # Sets the targets to the source in workflows, tracking the
+    # workflow type.
+    def set_workflow(type, source, targets) # :nodoc
+      # warn if workflows[source] is already set
+      @workflows[source] = [type, targets]
+    end
+    
+    # Sets a reverse workflow... ie the source is set to
+    # each target index.
+    def set_reverse_workflow(type, source, targets) # :nodoc
+      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]
+    end
+    
+    # Yields each round formatted as a string.
+    def each_round_str # :nodoc
+      rounds.each_with_index do |indicies, round_index|
+        unless indicies == nil
+          yield "+#{round_index}[#{indicies.join(',')}]"
+        end
+      end
+    end
+    
+    # Yields each workflow element formatted as a string.
+    def each_workflow_str # :nodoc
+      workflow.each_with_index do |(type, targets), source|
+        next if type == nil
+        
+        yield case type
+        when :sequence   then [source, *targets].join(":")
+        when :fork       then "#{source}[#{targets.join(',')}]"
+        when :merge      then "#{source}{#{targets.join(',')}}"
+        when :sync_merge then "#{source}(#{targets.join(',')})"
+        end
+      end
+    end
+  end
+end