bahuvrihi-tap 0.10.4 → 0.10.5

data/lib/tap/generator/base.rb

@@ -6,7 +6,7 @@ module Tap
       class << self
         def lazydoc(resolve=true)
           lazydoc = super(false)
-          lazydoc.register_method_pattern('args', :manifest, 1..-1) unless lazydoc.resolved?
+          lazydoc[self.to_s]['args'] ||= lazydoc.register_method(:manifest, Task::Args)
           super
         end
       end

data/lib/tap/generator/generators/config/templates/doc.erb

@@ -3,7 +3,7 @@
 ###############################################################################
 <% configurations.each do |key, config| %>
 
-<% Comment.wrap(config.desc.to_s.split(/\r?\n/), 50, 2).each do |line|  %>
+<% Lazydoc::Comment.wrap(config.desc.to_s, 50, 2).each do |line|  %>
 # <%=  line %>
 <% end %>
 <%= config.default == nil ? '#' : '' %><%= yamlize({key.to_s => config.default}) %>

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

@@ -17,7 +17,7 @@ class <%= const.name %>Test < Test::Unit::TestCase
     t = <%= const.name %>.new 
     assert_files do |input_files|
       input_files.each do |source|
-        target = method_filepath(:output, 'result.yml') 
+        target = method_root.filepath(:output, 'result.yml') 
         t.enq(source, target)
       end
     

data/lib/tap/generator/generators/root/templates/gemspec

@@ -5,24 +5,23 @@ Gem::Specification.new do |s|
   #s.email = "your.email@pubfactory.edu"
   #s.homepage = "http://rubyforge.org/projects/<%= project_name %>/"
   s.platform = Gem::Platform::RUBY
-  s.summary = "<%= project_name %> task library"
+  s.summary = "<%= project_name %>"
   s.require_path = "lib"
   s.test_file = "test/tap_test_suite.rb"
   #s.rubyforge_project = "<%= project_name %>"
   #s.has_rdoc = true
   s.add_dependency("tap", "~> <%= Tap::VERSION %>")
   
-  # list extra rdoc files like README here.
+  # list extra rdoc files here.
   s.extra_rdoc_files = %W{
+    README
   }
   
   # list the files you want to include here. you can
   # check this manifest using 'rake :print_manifest'
   s.files = %W{
 <%= config_file ? "    tap.yml\n" : '' %>
-<%= tapfile ? "    tapfile.rb\n" : '' %>
     test/tap_test_helper.rb
     test/tap_test_suite.rb
-    test/tapfile_test.rb
   }
 end

data/lib/tap/generator/generators/root/templates/tapfile

@@ -2,7 +2,7 @@ require 'tap'
 
 # Goodnight::manifest your basic goodnight moon task
 # Prints the input with a configurable message.
-Tap.task('goodnight', :message => 'goodnight') do |task, name|
-   task.log task.message, name
-   "#{task.message} #{name}"
+Tap.tasc('goodnight', :message => 'goodnight') do |name|
+  log message, name
+  "#{message} #{name}"
 end

data/lib/tap/parser.rb

@@ -378,6 +378,41 @@ module Tap
       segments
     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)
+      end
+
+      # build the workflow
+      workflow.each_with_index do |(type, target_indicies), source_index|
+        next if type == nil
+
+        targets = if target_indicies.kind_of?(Array)
+          target_indicies.collect {|i| instances[i][0] }
+        else
+          instances[target_indicies][0]
+        end
+        
+        instances[source_index][0].send(type, *targets)
+      end
+
+      # build queues
+      queues = rounds.collect do |round|
+        round.each do |index|
+          task, args = instances[index]
+          task.enq(*args)
+        end
+
+        app.queue.clear
+      end
+      queues.delete_if {|queue| queue.empty? }
+
+      queues
+    end
+    
     protected
     
     # Returns the index of the next argv to be parsed.

data/lib/tap/patches/optparse/summarize.rb

@@ -0,0 +1,62 @@
+#--
+# This patch fixes some formatting errors in OptParse.
+# In particular, long config names and config names of
+# 13 characters in length cause either ugly wrapping,
+# or an outright error.  It could also wrap long comments,
+# although that feature is currently disabled.
+#
+# See:
+# - http://bahuvrihi.lighthouseapp.com/projects/9908/tickets/97-unlucky-13-character-config-name#ticket-97-1
+
+class OptionParser # :nodoc:
+  class Switch # :nodoc:
+    undef_method :summarize
+    
+    def summarize(sdone = [], ldone = [], width = 1, max = width - 1, indent = "")
+      sopts, lopts = [], []
+      @short.each {|s| sdone.fetch(s) {sopts << s}; sdone[s] = true} if @short
+      @long.each {|s| ldone.fetch(s) {lopts << s}; ldone[s] = true} if @long
+      return if sopts.empty? and lopts.empty? # completely hidden
+
+      left = [sopts.join(', ')]
+      right = desc.dup
+
+      while str = lopts.shift
+        l = left[-1].length + str.length
+        l += arg.length if left.size == 1 && arg
+        #l < max or left << ''
+        left[-1] << if left[-1].empty? then ' ' * 4 else ', ' end << str
+      end
+
+      #left[0] << arg if arg
+      left[-1] << arg if arg
+
+      mlen = left.collect {|s| s.length}.max.to_i
+      while mlen > width and l = left.shift
+        mlen = left.collect {|s| s.length}.max.to_i if l.length == mlen
+        yield(indent + l)
+      end
+
+      # uncomment to justify long comments
+      # comment_indent = width + indent.length + 2
+      # split_right = []
+      # right.each do |obj|
+      #   start_index = 0
+      #   str = obj.to_str
+      #   while start_index < str.length
+      #     split_right << str[start_index, comment_indent].strip
+      #     start_index += comment_indent
+      #   end
+      # end
+      # right = split_right
+
+      while begin l = left.shift; r = right.shift; l or r end
+        l = l.to_s.ljust(width) + ' ' + r if r and !r.empty?
+        #yield(indent + l)
+        yield(indent + l) unless l == nil
+      end
+
+      self
+    end
+  end
+end

data/lib/tap/root.rb

@@ -78,19 +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
+      
+      # 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.  
@@ -293,8 +293,7 @@ module Tap
       #   Tap::Root.minimal_match?('dir/file-0.1.0.txt', 'r/file')        # => true
       #
       def minimal_match?(path, mini_path)
-        extname = File.extname(mini_path)
-        extname = '' if extname =~ /^\.\d+$/
+        extname = non_version_extname(mini_path)
         version = mini_path =~ /(-\d+(\.\d+)*)#{extname}$/ ? $1 : ''
    
         match_path = case
@@ -303,10 +302,10 @@ module Tap
           path
         when !version.empty?
           # match up to version
-          path.chomp(File.extname(path))
+          path.chomp(non_version_extname(path))
         else
           # match up base
-          path.chomp(File.extname(path)).sub(/(-\d+(\.\d+)*)$/, '')
+          path.chomp(non_version_extname(path)).sub(/(-\d+(\.\d+)*)$/, '')
         end
         
         # key ends with pattern AND basenames of each are equal... 
@@ -398,6 +397,13 @@ module Tap
         just_one
       end
       
+      # utility method for minimal_match --  returns a non-version 
+      # extname, or an empty string if the path ends in a version.
+      def non_version_extname(path) # :nodoc:
+        extname = File.extname(path)
+        extname =~ /^\.\d+$/ ? '' : extname
+      end
+      
     end
   
     include Support::Versions
@@ -540,7 +546,7 @@ module Tap
     # 
     #  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, source_dir, target_dir)
+    def translate(filepath, source_dir, target_dir)
       Root.translate(filepath, self[source_dir], self[target_dir])
     end
   

data/lib/tap/support/class_configuration.rb

@@ -125,7 +125,7 @@ module Tap
       def code_comments
         code_comments = []
         values.each do |config| 
-          code_comments << config.desc if config.desc.kind_of?(Comment)
+          code_comments << config.desc if config.desc.kind_of?(Lazydoc::Comment)
         end
         code_comments
       end

data/lib/tap/support/configurable_class.rb

@@ -1,6 +1,7 @@
 require 'tap/support/class_configuration'
 require 'tap/support/validation'
 require 'tap/support/lazy_attributes'
+require 'tap/support/lazydoc/config'
 
 module Tap
   module Support
@@ -251,7 +252,7 @@ module Tap
           case line
           when /in .config.$/ then next
           when Lazydoc::CALLER_REGEXP
-            options[:desc] = Lazydoc.register($1, $3.to_i - 1)
+            options[:desc] = Lazydoc.register($1, $3.to_i - 1, Lazydoc::Config)
             break
           end
         end if options[:desc] == nil
@@ -288,6 +289,7 @@ module Tap
         else nil
         end
       end
+
     end
   end
 end

data/lib/tap/support/configuration.rb

@@ -119,6 +119,25 @@ module Tap
         self.default(false) == another.default(false)
       end
       
+      def to_optparse_argv
+        argtype = case arg_type
+        when :optional 
+          "#{long} [#{arg_name}]"
+        when :switch 
+          long(true)
+        when :flag
+          long
+        when :list
+          "#{long} a,b,c"
+        when :mandatory, nil
+          "#{long} #{arg_name}"
+        else
+          raise "unknown arg_type: #{arg_type}"
+        end
+
+        [short, argtype, desc].compact
+      end
+      
     end
   end
 end

data/lib/tap/support/constant.rb

@@ -53,18 +53,30 @@ module Tap
         require_path ? Support::Lazydoc[require_path] : nil 
       end
       
+      # True if another is a Constant with the same name
+      # and require_path as self.
       def ==(another)
         another.kind_of?(Constant) && 
         another.name == self.name &&
         another.require_path == self.require_path
       end
-  
+      
+      # Looks up and returns the constant indicated by name.
+      # If the constant cannot be found, the constantize
+      # requires require_path and tries again.  Raises an
+      # NameError if the constant cannot be found.
       def constantize
         name.try_constantize do |const_name|
-          require require_path
+          require require_path if require_path
           name.constantize
         end
       end
+      
+      # Returns a string like:
+      #   "#<Tap::Support::Constant:object_id Const::Name (require_path)>"
+      def inspect
+        "#<#{self.class}:#{object_id} #{name}#{@require_path == nil ? "" : " (#{@require_path})"}>"
+      end
     end
   end
 end

data/lib/tap/support/declarations.rb

@@ -1,3 +1,5 @@
+require 'tap/support/lazydoc/declaration'
+
 module Tap
   module Support
     module Declarations
@@ -20,18 +22,6 @@ module Tap
       def tasc(name, configs={}, &block)
         declare(Tap::Task, name, configs, &block)
       end
-
-      def task(name, configs={}, &block)
-         mod_declare(Tap::Task, name, configs, &block)
-      end
-
-      def file_tasc(name, configs={}, &block)
-        declare(Tap::FileTask, name, configs, &block)
-      end
-
-      def file_task(name, configs={}, &block)
-         mod_declare(Tap::FileTask, name, configs, &block)
-      end
       
       protected
 
@@ -70,7 +60,7 @@ module Tap
         arity
       end
       
-      def declare(klass, declaration, configs={}, options={}, &block)
+      def parse(declaration)
         # Extract name and dependencies from declaration
         name, dependencies = case declaration
         when Hash then declaration.to_a[0]
@@ -100,38 +90,42 @@ module Tap
           end
         end
         
-        # Nest the constant name
+        [name, dependencies]
+      end
+      
+      def declare(klass, declaration, configs={}, options={}, &block)
+        # parse the declaration
+        name, dependencies = parse(declaration)
+        
+        # nest the constant name
         base = (self.kind_of?(Module) ? self : self.class).instance_variable_get(:@tap_declaration_base)
         name = File.join(base, name.to_s)
         
-        klass.subclass(name, configs, dependencies, options, &block)
-      end
-      
-      def mod_declare(klass, declaration, configs={}, &block)
-        options = {}
-        options[:arity] = arity(block) if block_given?
-
-        subclass = declare(klass, declaration, configs, options)
+        # generate the subclass
+        subclass = klass.subclass(name, configs, dependencies, options, &block)
         
-        if block_given?
-          mod = Module.new
-          mod.module_eval %Q{
-            ACTION = ObjectSpace._id2ref(#{block.object_id})
-            def process(*args)
-              results = super
-              case ACTION.arity
-              when 0 then ACTION.call
-              when 1 then ACTION.call(self)
-              else ACTION.call(self, *args)
-              end
-              results
-            end
-          }
-          subclass.send(:include, mod)
+        # register documentation
+        caller[1] =~ Lazydoc::CALLER_REGEXP
+        subclass.source_file = File.expand_path($1)
+        lazydoc = subclass.lazydoc(false)
+        lazydoc[subclass.to_s]['manifest'] = lazydoc.register($3.to_i - 1, Lazydoc::Declaration)
+
+        arity = options[:arity] || (block_given? ? block.arity : -1)
+        comment = Lazydoc::Comment.new
+        comment.subject = case
+        when arity > 0
+          Array.new(arity, "INPUT").join(' ')
+        when arity < 0
+          array = Array.new(-1 * arity - 1, "INPUT")
+          array << "INPUTS..."
+          array.join(' ')
+        else ""
         end
-        subclass.instance
+        lazydoc[subclass.to_s]['args'] ||= comment
+        
+        subclass
       end
-
+      
     end
   end
 end