shoulda 2.0.6 → 2.9.0

data/lib/shoulda/active_record/matchers/validation_matcher.rb

@@ -0,0 +1,56 @@
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers
+
+      class ValidationMatcher # :nodoc:
+
+        attr_reader :failure_message
+
+        def initialize(attribute)
+          @attribute = attribute
+        end
+
+        def negative_failure_message
+          @negative_failure_message || @failure_message
+        end
+
+        def matches?(subject)
+          @subject = subject
+          false
+        end
+
+        private
+
+        def allows_value_of(value, message = nil)
+          allow = AllowValueMatcher.
+            new(value).
+            for(@attribute).
+            with_message(message)
+          if allow.matches?(@subject)
+            @negative_failure_message = allow.failure_message
+            true
+          else
+            @failure_message = allow.negative_failure_message
+            false
+          end
+        end
+
+        def disallows_value_of(value, message = nil)
+          disallow = AllowValueMatcher.
+            new(value).
+            for(@attribute).
+            with_message(message)
+          if disallow.matches?(@subject)
+            @failure_message = disallow.negative_failure_message
+            false
+          else
+            @negative_failure_message = disallow.failure_message
+            true
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/shoulda/assertions.rb

@@ -1,49 +1,59 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module Assertions
-      # 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
+module Shoulda # :nodoc:
+  module Assertions
+    # 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 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
+      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
+    # 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
+    # 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 matcher returns true when +target+ is passed to #matches?
+    def assert_accepts(matcher, target)
+      success = matcher.matches?(target)
+      assert_block(matcher.failure_message) { success }
+    end
+
+    # Asserts that the given matcher returns false when +target+ is passed to #matches?
+    def assert_rejects(matcher, target)
+      success = !matcher.matches?(target)
+      assert_block(matcher.negative_failure_message) { success }
+    end
   end
 end

data/lib/shoulda/autoload_macros.rb

@@ -0,0 +1,46 @@
+module Shoulda # :nodoc:
+  # Call autoload_macros when you want to load test macros automatically in a non-Rails 
+  # project (it's done automatically for Rails projects).
+  # You don't need to specify ROOT/test/shoulda_macros explicitly. Your custom macros
+  # are loaded automatically when you call autoload_macros.
+  #
+  # The first argument is the path to you application's root directory.
+  # All following arguments are directories relative to your root, which contain 
+  # shoulda_macros subdirectories. These directories support the same kinds of globs as the 
+  # Dir class.
+  # 
+  # Basic usage (from a test_helper):
+  # Shoulda.autoload_macros(File.dirname(__FILE__) + '/..')
+  #	will load everything in 
+  #	- your_app/test/shoulda_macros
+  #
+  #	To load vendored macros as well:
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*')
+  #	will load everything in 
+  #	- APP_ROOT/vendor/*/shoulda_macros
+  #	- APP_ROOT/test/shoulda_macros
+  #
+  #	To load macros in an app with a vendor directory laid out like Rails':
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/{plugins,gems}/*')
+  # or
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/plugins/*', 'vendor/gems/*')
+  #	will load everything in 
+  #	- APP_ROOT/vendor/plugins/*/shoulda_macros
+  #	- APP_ROOT/vendor/gems/*/shoulda_macros
+  #	- APP_ROOT/test/shoulda_macros
+  #
+  #	If you prefer to stick testing dependencies away from your production dependencies:
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*', 'test/vendor/*')
+  #	will load everything in 
+  #	- APP_ROOT/vendor/*/shoulda_macros
+  #	- APP_ROOT/test/vendor/*/shoulda_macros
+  #	- APP_ROOT/test/shoulda_macros
+  def self.autoload_macros(root, *dirs)
+    dirs << File.join('test')
+    complete_dirs = dirs.map{|d| File.join(root, d, 'shoulda_macros')}
+    all_files     = complete_dirs.inject([]){ |files, dir| files + Dir[File.join(dir, '*.rb')] }
+    all_files.each do |file|
+      require file
+    end
+  end
+end

data/lib/shoulda/context.rb

@@ -1,26 +1,24 @@
-module Thoughtbot # :nodoc:
-  module Shoulda
-    VERSION = '2.0.6'
-
-    class << self
-      attr_accessor :contexts
-      def contexts # :nodoc:
-        @contexts ||= []
-      end
+module Shoulda
+  class << self
+    attr_accessor :contexts
+    def contexts # :nodoc:
+      @contexts ||= []
+    end
 
-      def current_context # :nodoc:
-        self.contexts.last
-      end
+    def current_context # :nodoc:
+      self.contexts.last
+    end
 
-      def add_context(context) # :nodoc:
-        self.contexts.push(context)
-      end
+    def add_context(context) # :nodoc:
+      self.contexts.push(context)
+    end
 
-      def remove_context # :nodoc:
-        self.contexts.pop
-      end
+    def remove_context # :nodoc:
+      self.contexts.pop
     end
+  end
 
+  module ClassMethods
     # == Should statements
     #
     # Should statements are just syntactic sugar over normal Test::Unit test methods.  A should block
@@ -29,7 +27,7 @@ module Thoughtbot # :nodoc:
     #
     # === Example:
     #
-    #  class UserTest << Test::Unit::TestCase
+    #  class UserTest < Test::Unit::TestCase
     #
     #    def setup
     #      @user = User.new("John", "Doe")
@@ -64,7 +62,7 @@ module Thoughtbot # :nodoc:
         block_given? ? Shoulda.current_context.should(name, options, &blk) : Should.current_context.should_eventually(name)
       else
         context_name = self.name.gsub(/Test/, "")
-        context = Thoughtbot::Shoulda::Context.new(context_name, self) do
+        context = Shoulda::Context.new(context_name, self) do
           block_given? ? should(name, options, &blk) : should_eventually(name)
         end
         context.build
@@ -104,7 +102,7 @@ module Thoughtbot # :nodoc:
     # Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
     def should_eventually(name, options = {}, &blk)
       context_name = self.name.gsub(/Test/, "")
-      context = Thoughtbot::Shoulda::Context.new(context_name, self) do
+      context = Shoulda::Context.new(context_name, self) do
         should_eventually(name, &blk)
       end
       context.build
@@ -118,7 +116,7 @@ module Thoughtbot # :nodoc:
     #
     # A context block can contain setup, should, should_eventually, and teardown blocks.
     #
-    #  class UserTest << Test::Unit::TestCase
+    #  class UserTest < Test::Unit::TestCase
     #    context "A User instance" do
     #      setup do
     #        @user = User.find(:first)
@@ -135,7 +133,7 @@ module Thoughtbot # :nodoc:
     # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each
     # should statement.  They then run their teardown blocks from in to out after each should statement.
     #
-    #  class UserTest << Test::Unit::TestCase
+    #  class UserTest < Test::Unit::TestCase
     #    context "A User instance" do
     #      setup do
     #        @user = User.find(:first)
@@ -168,139 +166,139 @@ module Thoughtbot # :nodoc:
       if Shoulda.current_context
         Shoulda.current_context.context(name, &blk)
       else
-        context = Thoughtbot::Shoulda::Context.new(name, self, &blk)
+        context = Shoulda::Context.new(name, self, &blk)
         context.build
       end
     end
+  end
 
-    class Context # :nodoc:
-
-      attr_accessor :name               # my name
-      attr_accessor :parent             # may be another context, or the original test::unit class.
-      attr_accessor :subcontexts        # array of contexts nested under myself
-      attr_accessor :setup_blocks       # blocks given via setup methods
-      attr_accessor :teardown_blocks    # blocks given via teardown methods
-      attr_accessor :shoulds            # array of hashes representing the should statements
-      attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
-
-      def initialize(name, parent, &blk)
-        Shoulda.add_context(self)
-        self.name               = name
-        self.parent             = parent
-        self.setup_blocks       = []
-        self.teardown_blocks    = []
-        self.shoulds            = []
-        self.should_eventuallys = []
-        self.subcontexts        = []
-
-        merge_block(&blk)
-        Shoulda.remove_context
-      end
+  class Context # :nodoc:
+
+    attr_accessor :name               # my name
+    attr_accessor :parent             # may be another context, or the original test::unit class.
+    attr_accessor :subcontexts        # array of contexts nested under myself
+    attr_accessor :setup_blocks       # blocks given via setup methods
+    attr_accessor :teardown_blocks    # blocks given via teardown methods
+    attr_accessor :shoulds            # array of hashes representing the should statements
+    attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
+
+    def initialize(name, parent, &blk)
+      Shoulda.add_context(self)
+      self.name               = name
+      self.parent             = parent
+      self.setup_blocks       = []
+      self.teardown_blocks    = []
+      self.shoulds            = []
+      self.should_eventuallys = []
+      self.subcontexts        = []
+
+      merge_block(&blk)
+      Shoulda.remove_context
+    end
 
-      def merge_block(&blk)
-        blk.bind(self).call
-      end
+    def merge_block(&blk)
+      blk.bind(self).call
+    end
 
-      def context(name, &blk)
-        self.subcontexts << Context.new(name, self, &blk)
-      end
+    def context(name, &blk)
+      self.subcontexts << Context.new(name, self, &blk)
+    end
 
-      def setup(&blk)
-        self.setup_blocks << blk
-      end
+    def setup(&blk)
+      self.setup_blocks << blk
+    end
 
-      def teardown(&blk)
-        self.teardown_blocks << blk
-      end
+    def teardown(&blk)
+      self.teardown_blocks << blk
+    end
 
-      def should(name, options = {}, &blk)
-        if block_given?
-          self.shoulds << { :name => name, :before => options[:before], :block => blk }
-        else
-         self.should_eventuallys << { :name => name }
-       end
-      end
+    def should(name, options = {}, &blk)
+      if block_given?
+        self.shoulds << { :name => name, :before => options[:before], :block => blk }
+      else
+       self.should_eventuallys << { :name => name }
+     end
+    end
 
-      def should_eventually(name, &blk)
-        self.should_eventuallys << { :name => name, :block => blk }
-      end
+    def should_eventually(name, &blk)
+      self.should_eventuallys << { :name => name, :block => blk }
+    end
 
-      def full_name
-        parent_name = parent.full_name if am_subcontext?
-        return [parent_name, name].join(" ").strip
-      end
+    def full_name
+      parent_name = parent.full_name if am_subcontext?
+      return [parent_name, name].join(" ").strip
+    end
 
-      def am_subcontext?
-        parent.is_a?(self.class) # my parent is the same class as myself.
-      end
+    def am_subcontext?
+      parent.is_a?(self.class) # my parent is the same class as myself.
+    end
 
-      def test_unit_class
-        am_subcontext? ? parent.test_unit_class : parent
-      end
+    def test_unit_class
+      am_subcontext? ? parent.test_unit_class : parent
+    end
 
-      def create_test_from_should_hash(should)
-        test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
+    def create_test_from_should_hash(should)
+      test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
 
-        if test_unit_class.instance_methods.include?(test_name.to_s)
-          warn "  * WARNING: '#{test_name}' is already defined"
-        end
+      if test_unit_class.instance_methods.include?(test_name.to_s)
+        warn "  * WARNING: '#{test_name}' is already defined"
+      end
 
-        context = self
-        test_unit_class.send(:define_method, test_name) do
-          begin
-            context.run_parent_setup_blocks(self)
-            should[:before].bind(self).call if should[:before]
-            context.run_current_setup_blocks(self)
-            should[:block].bind(self).call
-          ensure
-            context.run_all_teardown_blocks(self)
-          end
+      context = self
+      test_unit_class.send(:define_method, test_name) do
+        begin
+          context.run_parent_setup_blocks(self)
+          should[:before].bind(self).call if should[:before]
+          context.run_current_setup_blocks(self)
+          should[:block].bind(self).call
+        ensure
+          context.run_all_teardown_blocks(self)
         end
       end
+    end
 
-      def run_all_setup_blocks(binding)
-        run_parent_setup_blocks(binding)
-        run_current_setup_blocks(binding)
-      end
+    def run_all_setup_blocks(binding)
+      run_parent_setup_blocks(binding)
+      run_current_setup_blocks(binding)
+    end
 
-      def run_parent_setup_blocks(binding)
-        self.parent.run_all_setup_blocks(binding) if am_subcontext?
-      end
+    def run_parent_setup_blocks(binding)
+      self.parent.run_all_setup_blocks(binding) if am_subcontext?
+    end
 
-      def run_current_setup_blocks(binding)
-        setup_blocks.each do |setup_block|
-          setup_block.bind(binding).call
-        end
+    def run_current_setup_blocks(binding)
+      setup_blocks.each do |setup_block|
+        setup_block.bind(binding).call
       end
+    end
 
-      def run_all_teardown_blocks(binding)
-        teardown_blocks.reverse.each do |teardown_block|
-          teardown_block.bind(binding).call
-        end
-        self.parent.run_all_teardown_blocks(binding) if am_subcontext?
+    def run_all_teardown_blocks(binding)
+      teardown_blocks.reverse.each do |teardown_block|
+        teardown_block.bind(binding).call
       end
+      self.parent.run_all_teardown_blocks(binding) if am_subcontext?
+    end
 
-      def print_should_eventuallys
-        should_eventuallys.each do |should|
-          test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
-          puts "  * DEFERRED: " + test_name
-        end
+    def print_should_eventuallys
+      should_eventuallys.each do |should|
+        test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
+        puts "  * DEFERRED: " + test_name
       end
+    end
 
-      def build
-        shoulds.each do |should|
-          create_test_from_should_hash(should)
-        end
-
-        subcontexts.each { |context| context.build }
-
-        print_should_eventuallys
+    def build
+      shoulds.each do |should|
+        create_test_from_should_hash(should)
       end
 
-      def method_missing(method, *args, &blk)
-        test_unit_class.send(method, *args, &blk)
-      end
+      subcontexts.each { |context| context.build }
 
+      print_should_eventuallys
     end
+
+    def method_missing(method, *args, &blk)
+      test_unit_class.send(method, *args, &blk)
+    end
+
   end
 end