tap 0.11.1 → 0.12.0

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

@@ -1,8 +0,0 @@
-###############################################################################
-# <%= receiver %> configuration<%= configurations.length > 1 ? 's' : '' %>
-###############################################################################
-<% configurations.each do |key, config| %>
-<%= config.default == nil ? '#' : ''%><%= yamlize({key.to_s => config.default}) %>
-
-<% end %>
-

data/lib/tap/generator/generators/file_task/file_task_generator.rb

@@ -1,27 +0,0 @@
-require 'tap/generator/generators/task/task_generator'
-
-module Tap::Generator::Generators
-  
-  # :startdoc: Tap::Generator::Generators::FileTaskGenerator::generator a file_task and test
-  #
-  # Generates a new Tap::FileTask and associated test files.
-  class FileTaskGenerator < TaskGenerator
-    
-    def manifest(m, const_name)
-      const = super
-      
-      if test
-        test_dir = app.filepath('test', const.path, "test_#{const.basename}")
-        
-        m.directories test_dir, %W{
-          input
-          expected
-        }
-        
-        m.template File.join(test_dir, 'input/file.txt'), "file.txt", :const => const, :test_dir => test_dir
-        m.template File.join(test_dir, 'expected/result.yml'), "result.yml", :const => const, :test_dir => test_dir
-      end
-    end
-    
-  end
-end

data/lib/tap/generator/generators/file_task/templates/file.txt

@@ -1,11 +0,0 @@
-absquatulate - verb: This amusing, vivid, and expressive word is a bit of a jocular, contrived slang.  To absquatulate is to decamp, to scram, to take off in a hell of a hurry like a fugitive heading into the woods.
-
-algorism - noun: This is the name of the Arabic numbering system, using the figures 1 to 9 plus the zero.  The derivation is from Middle Latin algorismus, from the Arabic al (the) plus Khuwarizmi, the surname of a ninth-century Arabic mathematician.  Algorithm is sometimes used as a synonym, but is also used to designate a set of rules for the solution of a mathematical problem in a finite number of steps.  These words are entirely unrelated to algolagnia, with its very different meaning and derivation.
-
-defenestration - verb: Defenestration is the act of throwing someone (yes, someone!) or something out of a window.  To defenestrate a person or thing is to engage in this activity - a strange one indeed, since these words are more commonly applied to situations where what is thrown out of the window is a person, rather than a thing.  It is surprising, in view of what must be the infrequency of this type of activity, that there exists word for it, but then, there exists a word for just about everything.
-
-macaronic - adj: This peculiar word, a jocular concoction from macaroni, is applied, in a narrow sense, to language characterized by a mixture of Latin and non-Latin words, or by non-Latin words given phony Latin endings; in a broader sense, to prose or verse composed of any mixture of languages; in its broadest sense, to anything mixed or jumbled.
-
-trumpery - noun: Trumpery is worthless stuff.  
-
-usufruct - noun: Usufruct is a term used in law primarily, to denote one's right to enjoy the use and benefits flowing from the use of another's property, without the ownership of it and without the right to harm or waste or destroy it.

data/lib/tap/generator/generators/file_task/templates/result.yml

@@ -1,6 +0,0 @@
---- 
-- 111
-- 155
-- 123
-- 125
-- 56

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

@@ -1,33 +0,0 @@
-<% redirect do |target| %># <%= const.name %>::manifest <replace with manifest summary>
-# <replace with command line description>
-
-# <%= const.const_name %> Documentation
-# This example FileTask counts the specified letters
-# in a source file and writes the counts to a target
-# file as YAML.
-#
-class <%= const.const_name %> < Tap::FileTask
-
-  # <config file documentation>
-  config :letters, ['a','e','i','o','u'], &c.array  # a list of letters to count
-
-  def process(source, target)
-
-    # prepare ensures the parent directory for target
-    # exists and, if necessary, backs up the existing
-    # target file (which is restored on error)
-    prepare(target) 
-
-    # now perform the task...
-    str = File.read(source)
-    letter_count = letters.collect do |letter|
-      str.count(letter)
-    end
-
-    File.open(target, "wb") do |file|
-      file << YAML.dump(letter_count)
-    end
-
-    target
-  end
-end <% module_nest(const.nesting, '  ') { target } end %>

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

@@ -1,29 +0,0 @@
-require File.join(File.dirname(__FILE__), '<%= '../' * const.nesting_depth %>tap_test_helper.rb') 
-require '<%= const.path %>'
-
-class <%= const.name %>Test < Test::Unit::TestCase
-  acts_as_tap_test 
-  
-  def test_<%= const.basename %>
-    # Use assert_files to test file transform tasks.  The block  
-    # recieves the method input files and compares the results 
-    # to the method expected files.
-  
-    # Generated files are often placed in method output, as it
-    # is cleaned up each test.  To keep output files, set the 
-    # KEEP_OUTPUTS variable:
-    #   % rake test keep_outputs=true
-  
-    t = <%= const.name %>.new 
-    assert_files do |input_files|
-      input_files.each do |source|
-        target = method_root.filepath(:output, 'result.yml') 
-        t.enq(source, target)
-      end
-    
-      app.run
-      app.results(t)
-    end
-  end
-  
-end

data/lib/tap/generator/generators/root/templates/test/tap_test_suite.rb

@@ -1,5 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), '../lib')
-
-# runs all subsets (see Tap::Test::SubsetTest)
-ENV["ALL"] = "true"
-Dir.glob("./**/*_test.rb").each {|test| require test}

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

@@ -1,62 +0,0 @@
-#--
-# 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/support/assignments.rb

@@ -1,173 +0,0 @@
-module Tap
-  module Support
-    
-    # Assignments defines an array of [key, values] pairs that tracks 
-    # which values are assigned to a particular key.  A value may only 
-    # be assigned to one key at a time.  
-    #
-    # Assignments tracks the order of key declaration, and the
-    # order in which values are assigned to a key.  This behavior is
-    # used by ClassConfiguration to track the order of configurations  
-    # in a class; the order, in turn, is used in the formation
-    # of config files, command line documentation, etc.
-    #
-    #   a = Assignments.new
-    #   a.assign(:one, 'one')
-    #   a.assign(:two, 'two')
-    #   a.assign(:one, 'ONE')
-    #   a.to_a          # => [[:one, ['one', 'ONE']], [:two, ['two']]]
-    #
-    #   b = Assignments.new(a)
-    #   b.to_a          # => [[:one, ['one', 'ONE']], [:two, ['two']]]
-    #
-    #   b.unassign('one')
-    #   b.assign(:one, 1)
-    #   b.to_a          # => [[:one, ['ONE', 1]], [:two, ['two']]]
-    #   a.to_a          # => [[:one, ['one', 'ONE']], [:two, ['two']]]
-    #
-    #--
-    # TODO: 
-    #   Assignments may be optimizable... check if an alternate internal 
-    #   storage can be made faster or to take up less memory.  Not that
-    #   that much can be gained period...
-    class Assignments
-      include Enumerable
-      
-      # Generates a new Assignments using the parent array of
-      # [key, values] pairs.  Uses parent.array if parent is
-      # an Assignments, or [] if parent is nil.
-      def initialize(parent=nil)
-        existing_array = case parent
-        when Assignments then parent.array
-        when Array then parent
-        when nil then []
-        else 
-          raise ArgumentError.new("cannot convert #{parent.class} to Assignments, Array, or nil")
-        end
-        
-        @array = []
-        existing_array.each do |key, values|
-          assign(key, *values)
-        end
-      end
-      
-      # Adds the key to the declarations.
-      def declare(key)
-        array << [key, []] unless declared?(key)
-      end
-      
-      # Removes all values for the specified key and 
-      # removes the key from declarations.
-      def undeclare(key)
-        array.delete_if {|k, values| k == key}
-      end
-      
-      # Returns true if the key is declared.
-      def declared?(key)
-        array.each do |k, values|
-          return true if k == key
-        end
-        false
-      end
-      
-      # Returns an array of all the declared keys
-      def declarations
-        array.collect {|key, values| key }
-      end
-
-      # Assigns the specified values to the key.  The key will
-      # be declared, if necessary. Raises an error if the key
-      # is nil. 
-      def assign(key, *values)
-        raise ArgumentError.new("nil keys are not allowed") if key == nil
-        
-        # partition the input values into existing and new
-        # values, then check for conflicts.
-        current_values = self.values
-        existing_values, new_values = values.partition {|value| current_values.include?(value) }
-        
-        conflicts = []
-        existing_values.collect do |value|
-          current_key = key_for(value)
-          if current_key != key 
-            conflicts << "#{value} (#{key}) already assigned to #{current_key}"
-          end
-        end
-        
-        unless conflicts.empty?
-          raise ArgumentError.new(conflicts.join("\n"))
-        end
-        
-        declare(key)
-        values_for(key).concat new_values
-      end
-      
-      # Removes the specified value.
-      def unassign(value)
-        array.each do |key, values| 
-          values.delete(value)
-        end
-      end
-      
-      # Returns true if the value has been assigned to a key.
-      def assigned?(value)
-        array.each do |key, values|
-          return true if values.include?(value)
-        end
-        false
-      end
-
-      # Returns the ordered values as an array
-      def values
-        array.collect {|key, values| values}.flatten
-      end
-  
-      # Returns the key for the specified value, or nil 
-      # if the value is unassigned.
-      def key_for(value)
-        array.each do |key, values| 
-          return key if values.include?(value)
-        end
-        nil
-      end
-      
-      # Returns the values for the specified key, or nil if
-      # the key cannot be found.
-      def values_for(key)
-        array.each do |k, values| 
-          return values if k == key
-        end
-        nil
-      end
-
-      # Yields each [key, value] pair in the order in which
-      # the keys were declared. Keys with no values are 
-      # skipped.
-      def each
-        array.each do |key, values|
-          values.each {|value| yield(key, value) }
-        end
-      end
-      
-      # Yields each [key, values] pair in the order in which
-      # the keys were declared.
-      def each_pair
-        array.each do |key, values|
-          yield(key, values)
-        end
-      end
-      
-      # Returns self as an array
-      def to_a
-        array.collect {|key, values| [key, values.dup] }
-      end
-      
-      protected
-      
-      # An array of [key, values] arrays tracking the 
-      # order in which values are assigned. 
-      attr_reader :array
-      
-    end
-  end
-end

data/lib/tap/support/class_configuration.rb

@@ -1,182 +0,0 @@
-require 'tap/support/assignments'
-require 'tap/support/instance_configuration'
-require 'tap/support/configuration'
-
-module Tap
-  module Support
-    
-    # ClassConfiguration tracks configurations defined by a Configurable class.
-    class ClassConfiguration
-      include Enumerable
-      
-      config_templates_dir = File.expand_path File.dirname(__FILE__) + "/../generator/generators/config/templates"
-
-      # The path to the :doc template (see inspect)
-      DOC_TEMPLATE_PATH = File.join(config_templates_dir, 'doc.erb')
-
-      # The path to the :nodoc template (see inspect)
-      NODOC_TEMPLATE_PATH = File.join(config_templates_dir, 'nodoc.erb')
-      
-      # The Configurable class receiving new configurations
-      attr_reader :receiver
-
-      # An Assignments tracking the assignment of config keys to receivers
-      attr_reader :assignments
-      
-      # A map of [key, Configuration] pairs
-      attr_reader :map
-      
-      # Generates a new ClassConfiguration for the receiver.  If a parent is 
-      # provided, configurations will be inherited from it.
-      def initialize(receiver, parent=nil)
-        @receiver = receiver
-        
-        if parent != nil
-          @map = parent.map.inject({}) do |hash, (key, config)|
-            hash[key] = config.dup
-            hash
-          end
-          @assignments = Assignments.new(parent.assignments)
-        else
-          @map = {}
-          @assignments = Assignments.new
-        end
-      end
-
-      # Initializes a Configuration using the inputs and sets using name 
-      # as a key.  Any existing config by the same name is overridden. 
-      # Returns the new config.
-      def add(name, default=nil, attributes={})
-        self[name] = Configuration.new(name.to_sym, default, attributes)
-      end
-      
-      # Removes the specified configuration.
-      def remove(key)
-        self[key] = nil
-      end
-      
-      # Gets the config specified by key.  The key is symbolized.
-      def [](key)
-        map[key.to_sym]  
-      end
-      
-      # Assigns the config to key.  A nil config unassigns the
-      # configuration key.  The key is symbolized.
-      def []=(key, config)
-        key = key.to_sym
-        
-        if config == nil
-          assignments.unassign(key)
-          map.delete(key)
-        else
-          assignments.assign(receiver, key) unless assignments.assigned?(key)
-          map[key] = config
-        end
-      end
-      
-      # Returns true if key is a config key.
-      def key?(key)
-        map.has_key?(key)
-      end
-      
-      # Returns all config keys.
-      def keys
-        map.keys
-      end
-      
-      # Returns config keys in order.
-      def ordered_keys
-        assignments.values
-      end
-      
-      # Returns all mapped configs.
-      def values 
-        map.values
-      end
-      
-      # True if map is empty.
-      def empty?
-        map.empty?
-      end
-      
-      # Calls block once for each [receiver, key, config] in self, 
-      # passing those elements as parameters in the order in
-      # which they were assigned.  
-      def each
-        assignments.each do |receiver, key|
-          yield(receiver, key, map[key])
-        end
-      end
-      
-      # Calls block once for each [key, config] pair in self, 
-      # passing those elements as parameters in the order in
-      # which they were assigned.
-      def each_pair
-        assignments.each do |receiver, key|
-          yield(key, map[key])
-        end
-      end
-      
-      # Initializes and returns a new InstanceConfiguration set to self 
-      # and bound to the receiver, if specified.
-      def instance_config(receiver=nil, store={})
-        InstanceConfiguration.new(self, receiver, store)
-      end
-      
-      # Returns a hash of the [key, config.default] pairs in self.
-      def to_hash
-        hash = {}
-        each_pair {|key, config| hash[key] = config.default }
-        hash
-      end
-      
-      # An array of config descriptions that are Comment objects.
-      def code_comments
-        code_comments = []
-        values.each do |config| 
-          code_comments << config.desc if config.desc.kind_of?(Lazydoc::Comment)
-        end
-        code_comments
-      end
-      
-      # Inspects the configurations using the specified template.  Templates
-      # are used for format each [receiver, configurations] pair in self.
-      # See DEFAULT_TEMPLATE as a model.  The results of each template cycle
-      # are pushed to target.
-      #
-      # Two default templates are defined, <tt>:doc</tt> and <tt>:nodoc</tt>.
-      # These map to the contents of DOC_TEMPLATE_PATH and NODOC_TEMPLATE_PATH
-      # and correspond to the documented and undocumented 
-      # Tap::Generator::Generators::ConfigGenerator templates.
-      def inspect(template=:doc, target="")
-        Lazydoc.resolve_comments(code_comments)
-        
-        template = case template
-        when :doc then File.read(DOC_TEMPLATE_PATH)
-        when :nodoc then File.read(NODOC_TEMPLATE_PATH)
-        else template
-        end
-        
-        templater = Templater.new(template)
-        assignments.each_pair do |receiver, keys|
-          next if keys.empty?
-          
-          # set the template attributes
-          templater.receiver = receiver
-          templater.configurations = keys.collect do |key|
-            # duplicate config so that any changes to it
-            # during templation will not propogate back
-            # into self
-            [key, map[key].dup]
-          end.compact
-          
-          yield(templater) if block_given?
-          target << templater.build
-        end
-        
-        target
-      end
-    end
-  end
-end
-