tap 0.10.1 → 0.11.0

data/lib/tap/support/batchable.rb

@@ -1,47 +0,0 @@
-require 'tap/support/batchable_class'
-
-module Tap
-  module Support
-
-    # Batchable encapsulates the methods used to support batching
-    # of tasks. Classes including Batchable should call <tt>super</tt>
-    # during initialization to initialize batch, or they should 
-    # initialize batch themselves.
-    #
-    # See the 'Batches' section in the Tap::Task documentation for 
-    # details on how Batchable works in practice.
-    module Batchable
-    
-      def self.included(mod)
-        mod.extend Support::BatchableClass if mod.kind_of?(Class)
-      end
-      
-      # The object batch.
-      attr_reader :batch
-      
-      def initialize(batch=[])
-        @batch = batch
-        @batch << self
-      end
-    
-      # Returns true if the batch size is greater than one 
-      # (the one being self).  
-      def batched?
-        batch.length > 1
-      end
-
-      # Returns the index of the self in batch.
-      def batch_index
-        batch.index(self)
-      end
-      
-      # Initializes a new batch object and adds the object to batch.
-      # The object will be a duplicate of self.
-      def initialize_batch_obj
-        obj = self.dup
-        batch << obj
-        obj
-      end
-    end
-  end
-end

data/lib/tap/support/batchable_class.rb

@@ -1,107 +0,0 @@
-module Tap
-  module Support
-    
-    # BatchableClass encapsulates class methods related to Batchable.
-    module BatchableClass
-      
-      # Merges the batches for the specified objects.  All objects 
-      # sharing the individual object batches will be affected, even 
-      # if they are not listed explicitly as an input.
-      #
-      #  t1 = Tap::Task.new
-      #  t2 = Tap::Task.new
-      #  t3 = t2.initialize_batch_obj
-      #
-      #  Tap::Task.batch(t1, t2)
-      #  t3.batch                    # => [t1,t2,t3]
-      #
-      # Returns the new batch.
-      def batch(*batchables)
-        merged = []
-        batches = batchables.collect {|batchable| batchable.batch }.uniq
-        batches.each do |batch| 
-           merged.concat(batch)
-           batch.clear
-         end
-        merged.uniq!
-        batches.each {|batch| batch.concat(merged) }
-        merged
-      end
-      
-      protected
-      
-      # Redefines the specified method(s) as batched methods.  The existing method
-      # is renamed as <tt>unbatched_method</tt> and <tt>method</tt> redefined to 
-      # call <tt>unbatched_method</tt> on each object in the batch.
-      #
-      #   def process(one, two)
-      #     ...
-      #   end
-      #   batch_function(:process)
-      #
-      # Is equivalent to:
-      #
-      #   def unbatched_process(one, two)
-      #     ...
-      #   end
-      #
-      #   def process(one, two)
-      #     batch.each do |t|
-      #      t.unbatched_process(one, two)
-      #     end
-      #     self
-      #   end
-      #
-      # The batched method will accept/pass as many arguments as are defined for
-      # the unbatched method.  Splats are supported, and blocks are supported too 
-      # by passing a block to batch_function:
-      #
-      #   def process(arg, *args, &block)
-      #     ...
-      #   end
-      #   batch_function(:process) {}
-      #
-      # Is equivalent to:
-      #
-      #   def unbatched_process(arg, *args, &block)
-      #     ...
-      #   end
-      #
-      #   def process(*args, &block)
-      #     batch.each do |t|
-      #      t.unbatched_process(*args, &block)
-      #     end
-      #     self
-      #   end
-      #
-      # Obviously there are limitations to batch_function, most notably batching
-      # functions with default values.  In these cases, batch functionality
-      # must be implemented manually.
-      def batch_function(*methods)
-        methods.each do |method_name|
-          unbatched_method = "unbatched_#{method_name}"
-          if method_defined?(unbatched_method)
-            raise "unbatched method already defined: #{unbatched_method}"
-          end
-          
-          arity = instance_method(method_name).arity
-          args = case
-          when arity < 0 then "*args"
-          else Array.new(arity) {|index| "arg#{index}" }.join(", ")
-          end 
-          args += ", &block" if block_given?
- 
-          class_eval %Q{
-            alias #{unbatched_method} #{method_name}
-            def #{method_name}(#{args})
-              batch.each do |t|
-                t.#{unbatched_method}(#{args})
-              end
-              self
-            end
-          }
-        end
-      end
-    end 
-  end
-end

data/lib/tap/support/command_line.rb

@@ -1,98 +0,0 @@
-require 'optparse'
-
-module Tap
-  module Support
-    
-    # Under Construction
-    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
-        
-      def parse_usage(str, cols=80)
-        scanner = StringScanner.new(str)
-        scanner.scan(/^#!.*?$/)
-        Comment.parse(scanner, false).wrap(cols, 2).strip
-      end
-      
-      def configv(config)
-        desc = config.desc
-        desc.extend(OptParseComment) if desc.kind_of?(Comment)
-          
-        [config.short, argtype(config), desc].compact
-      end
-      
-      def argtype(config)
-        case config.arg_type
-        when :optional 
-          "#{config.long} [#{config.arg_name}]"
-        when :switch 
-          config.long(true)
-        when :flag
-          config.long
-        when :list
-          "#{config.long} a,b,c"
-        when :mandatory, nil
-          "#{config.long} #{config.arg_name}"
-        else
-          raise "unknown arg_type: #{config.arg_type}"
-        end
-      end
-      
-      module OptParseComment
-        def empty?
-          to_str.empty?
-        end
-
-        def to_str
-          subject.to_s =~ /#(.*)$/ ? $1.strip : ""
-        end
-      end
-    end
-  end
-end

data/lib/tap/support/comment.rb

@@ -1,270 +0,0 @@
-require 'strscan'
-
-module Tap
-  module Support 
-    # Comment represents a comment parsed by Lazydoc.
-    class Comment
-    
-      class << self
-      
-        # Parses the input string into a comment, stopping at end_regexp
-        # or the first non-comment line.  Also parses the next non-comment
-        # lines as the comment subject.  Takes a string or a StringScanner
-        # and returns the new comment.
-        #
-        #   comment_string = %Q{
-        #   # comments spanning multiple
-        #   # lines are collected
-        #   #
-        #   #   while indented lines
-        #   #   are preserved individually
-        #   #    
-        #   this is the subject line
-        #
-        #   # this line is not parsed as it
-        #   # is after a non-comment line
-        #   }
-        #
-        #   c = Comment.parse(comment_string)
-        #   c.lines   
-        #   # => [
-        #   # ['comments spanning multiple', 'lines are collected'],
-        #   # [''],
-        #   # ['  while indented lines'],
-        #   # ['  are preserved individually'],
-        #   # [''],
-        #   # []]
-        #   c.subject   # => "this is the subject line"
-        #
-        def parse(str, parse_subject=true) # :yields: fragment
-          scanner = case str
-          when StringScanner then str
-          when String then StringScanner.new(str)
-          else raise TypeError, "can't convert #{str.class} into StringScanner or String"
-          end
-        
-          comment = Comment.new
-          while scanner.scan(/\r?\n?[ \t]*#[ \t]?(([ \t]*).*?)\r?$/)
-            fragment = scanner[1]
-            indent = scanner[2]
-            
-            # collect continuous description line
-            # fragments and join into a single line
-            if block_given? && yield(fragment)
-              # break on comment if the description end is reached
-              parse_subject = false
-              break
-            else
-              categorize(fragment, indent) {|f| comment.push(f) }
-            end
-          end
-        
-          if parse_subject
-            scanner.skip(/\s+/)
-            unless scanner.peek(1) == '#'
-              comment.subject = scanner.scan(/.+?$/) 
-              comment.subject.strip! unless comment.subject == nil
-            end
-          end
-        
-          comment
-        end
-        
-        # Scans the line checking if it is a comment.  If so, scan
-        # yields the parse fragments to the block which correspond
-        # to the type of comment input (continuation, indent, etc).
-        # Returns true if the line is a comment, false otherwise.
-        #
-        # Scan may be used to build a comment from an array of lines:
-        #
-        #   lines = [
-        #     "# comments spanning multiple",
-        #     "# lines are collected",
-        #     "#",
-        #     "#   while indented lines",
-        #     "#   are preserved individually",
-        #     "#    ",
-        #     "not a comment line",
-        #     "# skipped since the loop breaks",
-        #     "# at the first non-comment line"]
-        #
-        #   c = Comment.new
-        #   lines.each do |line|
-        #     break unless Comment.scan(line) do |fragment|
-        #       # c.unshift will also work if building in reverse
-        #       c.push(fragment)  
-        #     end
-        #   end
-        #
-        #   c.lines   
-        #   # => [
-        #   # ['comments spanning multiple', 'lines are collected'],
-        #   # [''],
-        #   # ['  while indented lines'],
-        #   # ['  are preserved individually'],
-        #   # [''],
-        #   # []]
-        #
-        def scan(line) # :yields: fragment
-          return false unless line =~ /^[ \t]*#[ \t]?(([ \t]*).*?)\r?$/
-          categorize($1, $2) do |fragment|
-            yield(fragment)
-          end
-          true
-        end
-        
-        def wrap(lines, cols=80, tabsize=2)
-          lines = lines.split(/\r?\n/) unless lines.kind_of?(Array)
-          
-          lines.collect do |line|
-            line = line.gsub(/\t/, " " * tabsize) unless tabsize == nil
-
-            if line.strip.empty? 
-              line
-            else
-              # wrapping algorithm is slightly modified from 
-              # http://blog.macromates.com/2006/wrapping-text-with-regular-expressions/
-              line.gsub(/(.{1,#{cols}})( +|$\r?\n?)|(.{1,#{cols}})/, "\\1\\3\n").split(/\s*\n/)
-            end
-          end.flatten
-        end
-        
-        private
-        
-        def categorize(fragment, indent)
-           case
-           when fragment == indent
-             # empty comment line
-             yield [""]
-             yield []
-           when indent.empty?
-             # continuation line
-             yield fragment.rstrip
-           else 
-             # indented line
-             yield [fragment.rstrip]
-             yield []
-           end
-         end
-      end
-    
-      # An array of line fragment arrays.
-      attr_reader :lines
-    
-      # The next non-comment line after the comment ends.
-      # This is the line that would receive the comment
-      # in RDoc documentation.
-      attr_accessor :subject
-      
-      # Returns the line number for the subject line, if known.
-      attr_accessor :line_number
-    
-      def initialize(line_number=nil)
-        @lines = []
-        @subject = nil
-        @line_number = line_number
-      end
-
-      # Pushes the fragment onto the last line array.  If fragment is an
-      # array itself, then fragment will be pushed onto lines.
-      #
-      #   c = Comment.new
-      #   c.push "some line"
-      #   c.push "fragments"
-      #   c.push ["a", "whole", "new line"]
-      #   c.lines         # => [["some line", "fragments"], ["a", "whole", "new line"]]
-      #
-      def push(fragment)
-        lines << [] if lines.empty?
-        
-        case fragment
-        when Array
-          if lines[-1].empty? 
-            lines[-1] = fragment
-          else
-            lines.push fragment
-          end
-        else
-           lines[-1].push fragment
-        end
-      end
-      
-      # Alias for push.
-      def <<(fragment)
-        push(fragment)
-      end
-      
-      # Unshifts the fragment to the first line array.  If fragment is an
-      # array itself, then fragment will be unshifted onto lines.
-      #
-      #   c = Comment.new
-      #   c.unshift "some line"
-      #   c.unshift "fragments"
-      #   c.unshift ["a", "whole", "new line"]
-      #   c.lines         # => [["a", "whole", "new line"], ["fragments", "some line"]]
-      #
-      def unshift(fragment)
-        lines << [] if lines.empty?
-        
-        case fragment
-        when Array
-          if lines[0].empty? 
-            lines[0] = fragment
-          else
-            lines.unshift fragment
-          end
-        else
-           lines[0].unshift fragment
-        end
-      end
-      
-      def prepend(comment_line)
-        Comment.scan(comment_line) {|f| unshift(f) }
-      end
-      
-      def append(comment_line)
-        Comment.scan(comment_line) {|f| push(f) }
-      end
-      
-      # Removes leading and trailing lines that are empty ([]) 
-      # or whitespace (['']).  Returns self.
-      def trim
-        lines.shift while !lines.empty? && (lines[0].empty? || lines[0].join.strip.empty?)
-        lines.pop while !lines.empty? && (lines[-1].empty? || lines[-1].join.strip.empty?)
-        self
-      end
-      
-      # True if there are no fragments in self.
-      def empty?
-        !lines.find {|array| !array.empty?}
-      end
-      
-      def wrap(cols=80, tabsize=2, line_sep="\n", fragment_sep=" ", strip=true)
-        resolved_lines = Comment.wrap(to_s(fragment_sep, nil, strip), cols, tabsize)
-        line_sep ? resolved_lines.join(line_sep) : resolved_lines
-      end
-    
-      # Returns lines as a string where line fragments are joined by
-      # fragment_sep and lines are joined by line_sep. 
-      def to_s(fragment_sep=" ", line_sep="\n", strip=true)
-        resolved_lines = lines.collect {|line| line.join(fragment_sep)}
-        
-        # strip leading an trailing whitespace lines
-        if strip
-          resolved_lines.shift while !resolved_lines.empty? && resolved_lines[0].empty?
-          resolved_lines.pop while !resolved_lines.empty? && resolved_lines[-1].empty?
-        end
-        
-        line_sep ? resolved_lines.join(line_sep) : resolved_lines
-      end
-      
-      def ==(another)
-        another.kind_of?(Comment) && 
-        self.line_number == another.line_number &&
-        self.subject == another.subject &&
-        self.lines == another.lines
-      end
-
-    end
-  end
-end

data/lib/tap/support/constant_utils.rb

@@ -1,127 +0,0 @@
-module Tap
-  module Support
-    
-    # ConstantUtils provides methods for transforming strings into constants.
-    # Several methods are directly taken from or based heavily on the
-    # ActiveSupport {Inflections}[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
-    # module and should not cause conflicts if ActiveSupport is loaded
-    # alongside Tap.
-    #
-    # ActiveSupport is distributed with an MIT-LICENSE:
-    #
-    #   Copyright (c) 2004-2008 David Heinemeier Hansson
-    # 
-    #   Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
-    #   associated documentation files (the "Software"), to deal in the Software without restriction, 
-    #   including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
-    #   and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, 
-    #   subject to the following conditions:
-    # 
-    #   The above copyright notice and this permission notice shall be included in all copies or substantial 
-    #   portions of the Software.
-    # 
-    #   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
-    #   LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN 
-    #   NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
-    #   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
-    #   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-    #
-    module ConstantUtils
-      
-      # camelize converts self to UpperCamelCase. If the argument to 
-      # camelize is set to :lower then camelize produces lowerCamelCase.
-      # camelize will also convert '/' to '::' which is useful for
-      # converting paths to namespaces.
-      def camelize(first_letter = :upper)
-        case first_letter
-        when :upper then self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-        when :lower then self.first + camelize[1..-1]
-        end
-      end
-      
-      # The reverse of camelize. Makes an underscored, lowercase form 
-      # from self.  underscore will also change '::' to '/' to convert 
-      # namespaces to paths.
-      def underscore
-        self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-      end
-      
-      # constantize tries to find a declared constant with the name specified 
-      # by self. It raises a NameError when the name is not in CamelCase 
-      # or is not initialized.  
-      def constantize
-        case RUBY_VERSION
-        when /^1.9/
-
-          # a check is necessary to maintain the 1.8 behavior  
-          # in 1.9, where ancestor constants may be returned 
-          # by a direct evaluation
-          const_name.split("::").inject(Object) do |current, const|
-            const = const.to_sym
-
-            current.const_get(const).tap do |c|
-              unless current.const_defined?(const, false)
-                raise NameError.new("uninitialized constant #{const_name}") 
-              end
-            end
-          end
-
-        else 
-          Object.module_eval("::#{const_name}", __FILE__, __LINE__)
-        end
-      end
-      
-      # Tries to constantize self; if a NameError is raised, try_constantize
-      # passes control to the block.  Control is only passed if the NameError
-      # is for one of the constants in self.
-      def try_constantize
-        begin
-          constantize  
-        rescue(NameError)
-          error_name = $!.name.to_s 
-          missing_const = const_name.split(/::/).inject(Object) do |current, const|
-            if current.const_defined?(const) 
-              current.const_get(const) 
-            else 
-              break(const)
-            end
-          end
-
-          # check that the error_name is the first missing constant
-          raise $! unless missing_const == error_name
-          yield(const_name)
-        end
-      end
-      
-      def constants_split
-        camel_cased_word = camelize
-        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-          raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-        end
-
-        constants = $1.split(/::/)
-        current = Object
-        while !constants.empty?
-          break unless current.const_defined?(constants[0])
-          current = current.const_get(constants.shift)
-        end
-
-        [current, constants]
-      end
-
-      protected
-
-      def const_name
-        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
-          raise NameError, "#{inspect} is not a valid constant name!"
-        end
-        $1
-      end
-      
-    end
-  end
-end