bahuvrihi-tap 0.10.7 → 0.10.8

data/lib/tap/patches/ruby19/parsedate.rb

@@ -1,16 +0,0 @@
-require 'date/format'
-
-# Taken directly from the Ruby 1.8.6 standard library.  Ruby 1.9 has apparently
-# eliminated this class, but it is currently (2008-02-08) required by ActiveSupport.
-#
-# Making this file available to ActiveSupport allows testing under Ruby 1.9,
-# but this patch should be unnecessary when ActiveSupport upgrades and becomes
-# compatible with Ruby 1.9
-module ParseDate # :nodoc:
-  def parsedate(str, comp=false)
-    Date._parse(str, comp).
-      values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :wday)
-  end
-
-  module_function :parsedate
-end

data/lib/tap/spec.rb

@@ -1,42 +0,0 @@
-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,25 +0,0 @@
-module Tap
-  module Spec
-    module Adapter
-      def setup
-      end
-      
-      def teardown
-      end
-      
-      def method_name
-        self.description.strip.gsub(/\s+/, "_")
-      end
-      
-      # Maps flunk to violated.
-      def flunk(msg)
-        violated(msg)
-      end
-      
-      # Maps assert_equal to actual.should.equal expected.
-      def assert_equal(expected, actual, msg=nil)
-        actual.should == expected
-      end
-    end
-  end
-end

data/lib/tap/spec/inheritable_class_test_root.rb

@@ -1,9 +0,0 @@
-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/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

data/lib/tap/support/summary.rb

@@ -1,30 +0,0 @@
-module Tap
-  module Support
-    class Summary
-      def initialize
-        @map = []
-        @width = 10
-      end
-      
-      def add(env_key, env, map)
-        unless map.empty?
-          @map << [env_key, env, map]
-          map.each {|(key, path)| @width = key.length if @width < key.length }
-        end
-      end
-      
-      def lines
-        lines = []
-        @map.each do |(env_lookup, env, map)|
-          lines <<  "#{env_lookup}:" if @map.length > 1
-          map.each do |(key, path)|
-            desc = block_given? ? (yield(path) || '') : ''
-            desc = "  # #{desc}" unless desc.empty?
-            lines << ("  %-#{@width}s%s" % [key, desc])
-          end
-        end
-        lines
-      end
-    end
-  end
-end