giraffesoft-attribute_fu 0.2 → 0.2.1

data/test/vendor/plugins/shoulda/lib/shoulda/context.rb

@@ -1,143 +0,0 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    # = context and should blocks
-    # 
-    # A context block groups should statements under a common setup/teardown method.  
-    # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
-    # and readability of your test code.
-    #
-    # A context block can contain setup, should, should_eventually, and teardown blocks.
-    #
-    #  class UserTest << Test::Unit::TestCase
-    #    context "a User instance" do
-    #      setup do
-    #        @user = User.find(:first)
-    #      end
-    #    
-    #      should "return its full name"
-    #        assert_equal 'John Doe', @user.full_name
-    #      end
-    #    end
-    #  end
-    #
-    # This code will produce the method <tt>"test a User instance should return its full name"</tt>.
-    #
-    # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each test.  
-    # They then run their teardown blocks from in to out after each test.
-    #
-    #  class UserTest << Test::Unit::TestCase
-    #    context "a User instance" do
-    #      setup do
-    #        @user = User.find(:first)
-    #      end
-    #    
-    #      should "return its full name"
-    #        assert_equal 'John Doe', @user.full_name
-    #      end
-    #    
-    #      context "with a profile" do
-    #        setup do
-    #          @user.profile = Profile.find(:first)
-    #        end
-    #      
-    #        should "return true when sent :has_profile?"
-    #          assert @user.has_profile?
-    #        end
-    #      end
-    #    end
-    #  end
-    #
-    # This code will produce the following methods 
-    # * <tt>"test: a User instance should return its full name."</tt>
-    # * <tt>"test: a User instance with a profile should return true when sent :has_profile?."</tt>
-    #
-    # <b>A context block can exist next to normal <tt>def test_the_old_way; end</tt> tests</b>, 
-    # meaning you do not have to fully commit to the context/should syntax in a test file.
-    #
-  
-    module Context
-      def Context.included(other) # :nodoc:
-        @@context_names   = []
-        @@setup_blocks    = []
-        @@teardown_blocks = []
-      end
-    
-      # Defines a test method.  Can be called either inside our outside of a context.
-      # Optionally specify <tt>:unimplimented => true</tt> (see should_eventually).
-      #
-      # Example:
-      #
-      #   class UserTest << Test::Unit::TestCase 
-      #     should "return first user on find(:first)"
-      #       assert_equal users(:first), User.find(:first)
-      #     end
-      #   end
-      #
-      # Would create a test named
-      #   'test: should return first user on find(:first)'
-      #
-      def should(name, opts = {}, &should_block)
-        test_name = ["test:", @@context_names, "should", "#{name}. "].flatten.join(' ').to_sym
-
-        name_defined = eval("self.instance_methods.include?('#{test_name.to_s.gsub(/['"]/, '\$1')}')", should_block.binding)
-        raise ArgumentError, "'#{test_name}' is already defined" and return if name_defined
-      
-        setup_blocks    = @@setup_blocks.dup
-        teardown_blocks = @@teardown_blocks.dup
-      
-        if opts[:unimplemented]
-          define_method test_name do |*args|
-            # XXX find a better way of doing this.
-            assert true
-        	  STDOUT.putc "X" # Tests for this model are missing.
-          end    		
-        else
-          define_method test_name do |*args|
-            begin
-              setup_blocks.each {|b| b.bind(self).call }
-              should_block.bind(self).call(*args)
-            ensure
-              teardown_blocks.reverse.each {|b| b.bind(self).call }
-            end
-          end
-        end
-      end
-
-      # Creates a context block with the given name.
-      def context(name, &context_block)
-        saved_setups    = @@setup_blocks.dup
-        saved_teardowns = @@teardown_blocks.dup      
-        saved_contexts  = @@context_names.dup
-
-        @@context_names << name
-        context_block.bind(self).call
-
-        @@context_names   = saved_contexts      
-        @@setup_blocks    = saved_setups
-        @@teardown_blocks = saved_teardowns
-      end
-
-      # Run before every should block in the current context.
-      # If a setup block appears in a nested context, it will be run after the setup blocks
-      # in the parent contexts.
-      def setup(&setup_block)
-        @@setup_blocks << setup_block
-      end
-
-      # Run after every should block in the current context.
-      # If a teardown block appears in a nested context, it will be run before the teardown 
-      # blocks in the parent contexts.
-      def teardown(&teardown_block)
-        @@teardown_blocks << teardown_block
-      end
-
-      # Defines a specification that is not yet implemented.  
-      # Will be displayed as an 'X' when running tests, and failures will not be shown.
-      # This is equivalent to:
-      #   should(name, {:unimplemented => true}, &block)
-      def should_eventually(name, &block)
-        should("eventually #{name}", {:unimplemented => true}, &block)
-      end
-    end
-  end
-end

data/test/vendor/plugins/shoulda/lib/shoulda/general.rb

@@ -1,119 +0,0 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module General
-      def self.included(other) # :nodoc:
-        other.class_eval do
-          extend ThoughtBot::Shoulda::General::ClassMethods
-          # include ThoughtBot::Shoulda::General::InstanceMethods
-        end
-      end
-      
-      module ClassMethods
-        # Loads all fixture files (<tt>test/fixtures/*.yml</tt>)
-        def load_all_fixtures
-          all_fixtures = Dir.glob(File.join(Test::Unit::TestCase.fixture_path, "*.yml")).collect do |f| 
-            File.basename(f, '.yml').to_sym
-          end
-          fixtures *all_fixtures
-        end
-      end
-      
-      # Prints a message to stdout, tagged with the name of the calling method.
-      def report!(msg = "")
-        puts("#{caller.first}: #{msg}")
-      end
-
-      # Ensures that the number of items in the collection changes
-      #
-      #   assert_difference(User, :count, 1) { User.create }
-      #   assert_difference(User.packages, :size, 3, true) { User.add_three_packages }
-      #
-      # Setting reload to true will call <tt>object.reload</tt> after the block (for ActiveRecord associations)
-      def assert_difference(object, method, difference, reload = false, msg = nil)
-        initial_value = object.send(method)
-        yield
-        object.send(:reload) if reload
-        assert_equal initial_value + difference, object.send(method), (msg || "#{object}##{method} after block")
-      end
-
-      # Ensures that object.method does not change.  See assert_difference for usage.
-      def assert_no_difference(object, method, reload = false, msg = nil, &block)
-        assert_difference(object, method, 0, reload, msg, &block)
-      end
-
-      # Asserts that two arrays contain the same elements, the same number of times.  Essentially ==, but unordered.
-      #
-      #   assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
-      def assert_same_elements(a1, a2, msg = nil)
-        [:select, :inject, :size].each do |m|
-          [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
-        end
-
-        assert a1h = a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h }
-        assert a2h = a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
-
-        assert_equal(a1h, a2h, msg)
-      end
-
-      # Asserts that the given collection contains item x.  If x is a regular expression, ensure that
-      # at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
-      #
-      #   assert_contains(['a', '1'], /\d/) => passes
-      #   assert_contains(['a', '1'], 'a') => passes
-      #   assert_contains(['a', '1'], /not there/) => fails
-      def assert_contains(collection, x, extra_msg = "")
-        collection = [collection] unless collection.is_a?(Array)
-        msg = "#{x.inspect} not found in #{collection.to_a.inspect} " + extra_msg
-        case x
-        when Regexp: assert(collection.detect { |e| e =~ x }, msg)
-        else         assert(collection.include?(x), msg)
-        end        
-      end
-
-      # Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
-      # none of the elements from the collection match x.
-      def assert_does_not_contain(collection, x, extra_msg = "")
-        collection = [collection] unless collection.is_a?(Array)
-        msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
-        case x
-        when Regexp: assert(!collection.detect { |e| e =~ x }, msg)
-        else         assert(!collection.include?(x), msg)
-        end        
-      end
-      
-      # Asserts that the given object can be saved
-      #
-      #  assert_save User.new(params)
-      def assert_save(obj)
-        assert obj.save, "Errors: #{obj.errors.full_messages.join('; ')}"
-        obj.reload
-      end
-
-      # Asserts that the given object is valid
-      #
-      #  assert_save User.new(params)
-      def assert_valid(obj)
-        assert obj.valid?, "Errors: #{obj.errors.full_messages.join('; ')}"
-      end
-      
-      # Asserts that the block uses ActionMailer to send emails
-      #
-      #  assert_sends_email(2) { Mailer.deliver_messages }
-      def assert_sends_email(num = 1, &blk)
-        ActionMailer::Base.deliveries.clear
-        blk.call
-        msg = "Sent #{ActionMailer::Base.deliveries.size} emails, when #{num} expected:\n"
-        ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
-        assert(num == ActionMailer::Base.deliveries.size, msg)
-      end
-
-      # Asserts that the block does not send emails thorough ActionMailer
-      #
-      #  assert_does_not_send_email { # do nothing }
-      def assert_does_not_send_email(&blk)
-        assert_sends_email 0, &blk
-      end
-      
-    end
-  end
-end

data/test/vendor/plugins/shoulda/lib/shoulda/private_helpers.rb

@@ -1,17 +0,0 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module Private # :nodoc:
-      def get_options!(args, *wanted)
-        ret  = []
-        opts = (args.last.is_a?(Hash) ? args.pop : {})
-        wanted.each {|w| ret << opts.delete(w)}
-        raise ArgumentError, "Unsuported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
-        return *ret
-      end
-
-      def model_class
-        self.name.gsub(/Test$/, '').constantize
-      end
-    end
-  end
-end