bahuvrihi-tap 0.10.6 → 0.10.7

data/lib/tap/env.rb

@@ -190,6 +190,9 @@ module Tap
     # Specify files to require when self is activated.
     config :requires, [], &c.array_or_nil
     
+    # Specify files to load when self is activated.
+    config :loads, [], &c.array_or_nil
+    
     # Specify gems to load as nested Envs.  Gems may be specified 
     # by name and/or version, like 'gemname >= 1.2'; by default the 
     # latest version of the gem is selected.
@@ -245,7 +248,7 @@ module Tap
       next unless File.file?(path) && document = Support::Lazydoc.scan_doc(path, 'manifest')
       
       document.default_const_name = env.root.relative_filepath(load_path, path).chomp('.rb').camelize
-      document.const_attrs.keys.collect do |const_name|
+      document.const_names.collect do |const_name|
         [const_name.underscore, Support::Constant.new(const_name, path)]
       end
     end
@@ -260,7 +263,7 @@ module Tap
       
       next unless document = Support::Lazydoc.scan_doc(path, 'generator')
       document.default_const_name = "#{env.root.relative_filepath(generator_path, dirname)}_generator".camelize
-      document.const_attrs.keys.collect do |const_name|
+      document.const_names.collect do |const_name|
         [const_name.underscore.chomp('_generator'), Support::Constant.new(const_name, path)]
       end
     end
@@ -458,6 +461,11 @@ module Tap
         require path
       end
       
+      # perform loads
+      loads.each do |path|
+        load path
+      end
+      
       true
     end
     

data/lib/tap/exe.rb

@@ -1,6 +1,6 @@
 require 'tap/env'
 require 'tap/app'
-require 'tap/parser'
+require 'tap/support/schema'
 
 module Tap
   class Exe < Env
@@ -74,7 +74,7 @@ module Tap
     end
 
     def build(argv=ARGV)
-      Parser.new(argv).build(app) do |args|
+      Support::Schema.parse(argv).compact.build(app) do |args|
         task = args.shift
         const = search(:tasks, task) 
         

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

@@ -58,6 +58,7 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = '<%= project_name %>'
+  rdoc.main     = 'README'
   rdoc.options << '--line-numbers' << '--inline-source'
   rdoc.rdoc_files.include( spec.extra_rdoc_files )
   rdoc.rdoc_files.include( spec.files.select {|file| file =~ /^lib.*\.rb$/} )

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

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

data/lib/tap/spec.rb

@@ -1,67 +1,42 @@
-module Tap
-  module Spec
-    
-    def self.included(base)
-      super
-      base.send(:include, Tap::Spec::Adapter)
-    end
-    
-    # Causes a TestCase to act as a file test, by instantiating a class Tap::Root 
-    # (trs), and including FileMethods.  The root and directories used to 
-    # instantiate trs can be specified as options.  By default file_test_root
-    # and the directories {:input => 'input', :output => 'output', :expected => 'expected'} 
-    # will be used.
-    #
-    # Note: file_test_root determines a root directory <em>based on the calling file</em>.  
-    # Be sure to specify the root directory explicitly if you call acts_as_file_test
-    # from a file that is NOT meant to be test file.
-    def acts_as_file_spec(options={})
-      include Tap::Spec::FileMethods
-      
-      options = {
-        :root => file_test_root,
-        :directories => {:input => 'input', :output => 'output', :expected => 'expected'}
-      }.merge(options)
-      self.trs = Tap::Root.new(options[:root], options[:directories])
-    end
-
-    # Causes a unit test to act as a tap test -- resulting in the following:
-    # - setup using acts_as_file_test
-    # - inclusion of Tap::Test::SubsetMethods
-    # - inclusion of Tap::Test::InstanceMethods 
-    #
-    # Note:  Unless otherwise specified, <tt>acts_as_tap_test</tt> infers a root directory
-    # based on the calling file. Be sure to specify the root directory explicitly 
-    # if you call acts_as_file_test from a file that is NOT meant to be test file.
-    # def acts_as_tap_spec(options={})
-    #   include Tap::Test::SubsetMethods
-    #   include Tap::Test::FileMethods
-    #   include Tap::Test::TapMethods
-    #   
-    #   acts_as_file_test({:root => file_test_root}.merge(options))
-    # end
-    # 
-    # def acts_as_script_spec(options={})
-    #   include Tap::Test::FileMethods
-    #   include Tap::Test::ScriptMethods
-    #   
-    #   acts_as_file_test({:root => file_test_root}.merge(options))
-    # end
-  end
-end
-
-module Tap
-  
-  # Modules facilitating testing.  TapMethods are specific to
-  # Tap, but SubsetMethods and FileMethods are more general in 
-  # their utility.
-  module Spec
-    autoload(:SubsetMethods, 'tap/spec/subset_methods')
-    autoload(:FileMethods, 'tap/spec/file_methods')
-    autoload(:TapMethods, 'tap/spec/tap_methods')
-  end
-end
+require 'tap/test/extensions'
+require 'tap/spec/adapter'
+require 'tap/spec/inheritable_class_test_root'
 
+module Spec
+  module Example
+    class ExampleGroup
+      extend Tap::Test::Extensions
+      include Tap::Spec::Adapter
+      
+      class << self
+        def acts_as_file_test(*args)
+          super
+          extend Tap::Spec::InheritableClassTestRoot
+        end
 
+        private
 
+        # Infers the test root directory from the calling file.
+        #   'some_class.rb' => 'some_class'
+        #   'some_class_test.rb' => 'some_class'
+        def test_root_dir # :nodoc:
+          # caller[2] is considered the calling file (which should be the test case)
+          # note that caller entries are like this:
+          #   ./path/to/file.rb:10
+          #   ./path/to/file.rb:10:in 'method'
 
+          calling_file = caller[2].gsub(/:\d+(:in .*)?$/, "")
+          calling_file.chomp(File.extname(calling_file)).chomp("_spec") 
+        end
+      end
+      
+      before(:each) do
+        setup
+      end
+      
+      after(:each) do
+        teardown
+      end
+    end
+  end
+end

data/lib/tap/spec/adapter.rb

@@ -1,37 +1,14 @@
 module Tap
   module Spec
     module Adapter
-      def method_name
-        self.description.strip.gsub(/\s+/, "_")
+      def setup
+      end
+      
+      def teardown
       end
       
-      # A method serving as the dumping ground for 'should ==' statements
-      # that otherwise cause a 'useless use of <method> in void context' 
-      # warning. Useful if you're running tests with -w.
-      #
-      #   check 1.should == 1
-      #
-      # Check will validate that the line calling check contains a 
-      # should/should_not statement; the check fails if it does not.
-      def check(return_value)
-        return false unless SCRIPT_LINES__
-        
-        caller[0] =~ /^(([A-z]:)?[^:]+):(\d+)/
-
-        check_file = SCRIPT_LINES__[$1]
-        violated("could not validate check: #{$1} (#{$3})") unless check_file 
-
-        # note the line number in caller 
-        # starts at 1, not 0
-        line = check_file[$3.to_i - 1]
-        case line
-        when /\.should(_not)?[^\w]/ 
-          true # pass
-        when /^\s+check/
-          violated("check used without should/should_not statement: #{line} (#{caller[0]})")
-        else
-          violated("multiline check statements are not allowed: #{caller[0]}")
-        end
+      def method_name
+        self.description.strip.gsub(/\s+/, "_")
       end
       
       # Maps flunk to violated.
@@ -39,9 +16,9 @@ module Tap
         violated(msg)
       end
       
-      # Maps assert_equal to actual.should == expected.
+      # Maps assert_equal to actual.should.equal expected.
       def assert_equal(expected, actual, msg=nil)
-        check actual.should == expected
+        actual.should == expected
       end
     end
   end

data/lib/tap/spec/inheritable_class_test_root.rb

@@ -0,0 +1,9 @@
+module Tap
+  module Spec
+    module InheritableClassTestRoot
+      def class_test_root
+        @class_test_root ||= (superclass.respond_to?(:class_test_root) ? superclass.class_test_root : nil)
+      end
+    end
+  end
+end

data/lib/tap/support/audit.rb

@@ -1,5 +1,3 @@
-autoload(:PP, 'pp')
-      
 module Tap
   module Support 
     

data/lib/tap/support/combinator.rb

@@ -1,21 +1,64 @@
-module Tap
+require 'enumerator'
+
+module Tap 
   module Support
+    
+    # Combinator provides a method for iterating over all combinations
+    # of items in the input sets.
+    #
+    #   c = Combinator.new [1,2], [3,4]
+    #   c.to_a            # => [[1,3], [1,4], [2,3], [2,4]]
+    #
+    # Combinators can take any object that responds to :each as an
+    # input set; normally arrays are used.
+    #
+    # === Implementation
+    #
+    # Combinator iteratively combines each element from the first set (a)
+    # with each element from the second set (b).  When more than two sets
+    # are given, the Combinator bundles all but the first set into a new 
+    # Combinator, which then acts as the second set.
+    #
+    #   c = Combinator.new [1,2], [3,4], [5,6]
+    #   c.a               # => [[1],[2]]
+    #   c.b.class         # => Combinator
+    #   c.b.a             # => [[3],[4]]
+    #   c.b.b             # => [[5],[6]]
+    #
+    # Note that internally each item in a set is stored as a single-item
+    # array; the arrays are added during combination.  Thus when 
+    # iterating, the combinations are calculated like:
+    #
+    #   ([1] + [3]) + [5] # => [1,3,5]
+    #
+    # This is probably not the fastest implementation, but it works.
     class Combinator
-      attr_reader :a, :b
+      include Enumerable
+      
+      # The first set.
+      attr_reader :a
+      
+      # The second set.
+      attr_reader :b
 
+      # Creates a new Combinator.  Input sets must be an Array, or nil.
+      # Within the Array any objects are allowed for combination.
       def initialize(*sets)
         @a = make_set(sets.shift)
         @b = make_set(*sets)
       end
 
+      # Returns the sets used to initialize the Combinator.
       def sets
-        sets_in(@a) + sets_in(@b)
+        sets_in(a) + sets_in(b)
       end
 
+      # True if length is zero.
       def empty?
-        @a.empty? && @b.empty?
+        a.empty? && b.empty?
       end
 
+      # Returns the number of combinations returned by each.
       def length
         case
         when !(@a.empty? || @b.empty?)
@@ -27,47 +70,56 @@ module Tap
         end
       end
 
+      # Passes each combination as an array to the input block.
       def each
         case
         when !(@a.empty? || @b.empty?)
-          @a.each do |*a|
-            @b.each do |*b|
-              yield(*(a + b))
+          @a.each do |a|
+            @b.each do |b|
+              yield(a + b)
             end
           end
         when @a.empty? 
-          @b.each {|*b| yield(*b) }
+          @b.each {|b| yield(b) }
         when @b.empty? 
-          @a.each {|*a| yield(*a) }
+          @a.each {|a| yield(a) }
         end
       end
 
-      def collect
-        cc = []
-        each do |*c| 
-          cc << (block_given? ? yield(*c) : c)
-        end 
-        cc
-      end
-
-      protected
-
-      def sets_in(set)
-        set.kind_of?(Array) ? (set.empty? ? [] : [set]) : set.sets
-      end
-
-      def make_set(*sets)
+      private
+      
+      # makes a Combinator out of multiple sets or collects the
+      # objects of a single set as arrays:
+      #
+      #   make_set([1,2,3], [4,5,6])  # => Combinator.new([1,2,3], [4,5,6])
+      #   make_set([1,2,3])           # => [[1],[2],[3]]
+      #
+      def make_set(*sets) # :nodoc:
+        # recieves an array of arrays or combinators
         return Combinator.new(*sets) if sets.length > 1 
-        return [] if sets.empty?
+        return sets if sets.empty?
+        
+        set = sets[0]
+        return [] if set == nil
+        
+        unless set.respond_to?(:each)
+          raise ArgumentError, "does not respond to each: #{set}"
+        end
+        
+        # recursively arrayifies each element
+        arrayified_set = []
+        set.each {|s| arrayified_set << [s]}
+        arrayified_set
+      end
 
-        set = sets.first
-        case set 
-        when Combinator then set
-        when Array then set
-        when nil then []
-        else [set]
+      # basically the reverse of make_set
+      def sets_in(set) # :nodoc:
+        case set
+        when Combinator then set.sets
+        when Array then set.empty? ? [] : [set.collect {|s| s[0]}]
         end
       end
+      
     end
   end
 end

data/lib/tap/support/configurable_class.rb

@@ -271,10 +271,10 @@ module Tap
       # blocks, such as switch (Validation::SWITCH) and list
       # (Validation::LIST).
       def arg_type(block) # :nodoc:
-        case block
-        when Validation::SWITCH then :switch
-        when Validation::FLAG then :flag
-        when Validation::LIST then :list
+        case 
+        when block == Validation::SWITCH then :switch
+        when block == Validation::FLAG then :flag
+        when block == Validation::LIST then :list
         else nil
         end
       end
@@ -283,9 +283,9 @@ module Tap
       # blocks, such as switch (Validation::ARRAY) and list
       # (Validation::HASH).
       def arg_name(block) # :nodoc:
-        case block
-        when Validation::ARRAY then "'[a, b, c]'"
-        when Validation::HASH then "'{one: 1, two: 2}'"
+        case
+        when block == Validation::ARRAY then "'[a, b, c]'"
+        when block == Validation::HASH then "'{one: 1, two: 2}'"
         else nil
         end
       end

data/lib/tap/support/{dependable.rb → dependencies.rb}

@@ -3,9 +3,11 @@ module Tap
     
     # Dependable encapsulates the module-level methods facilitating 
     # dependencies in Executable.
-    module Dependable
-      def self.extended(base)
-        base.clear_dependencies
+    class Dependencies
+      def initialize
+        @registry = []
+        @results = []
+        @resolve_stack = []
       end
       
       # An array of registered [instance, argv] pairs.
@@ -16,10 +18,10 @@ module Tap
       attr_reader :results
       
       # Clears all registered dependencies and results.  
-      def clear_dependencies
-        @registry = []
-        @results = []
-        @resolve_stack = []
+      def clear
+        registry.clear
+        results.clear
+        @resolve_stack.clear
       end
       
       # Returns the index of the [instance, argv] pair in self,