shoulda-matchers 2.7.0 → 2.8.0.rc1

data/lib/shoulda/matchers/independent/delegate_method_matcher.rb

@@ -31,9 +31,24 @@ module Shoulda
       #       should delegate_method(:deliver).to(:post_office)
       #     end
       #
+      # You can also use `delegate_method` with Rails's `delegate` macro:
+      #
+      #     class Courier
+      #       attr_reader :post_office
+      #       delegate :deliver, to: :post_office
+      #
+      #       def initialize
+      #         @post_office = PostOffice.new
+      #       end
+      #     end
+      #
+      #     describe Courier do
+      #       it { should delegate_method(:deliver).to(:post_office) }
+      #     end
+      #
       # To employ some terminology, we would say that Courier's #deliver method
-      # is the delegating method, PostOffice is the delegate object, and
-      # PostOffice#deliver is the delegate method.
+      # is the *delegating method*, PostOffice is the *delegate object*, and
+      # PostOffice#deliver is the *delegate method*.
       #
       # #### Qualifiers
       #
@@ -67,6 +82,31 @@ module Shoulda
       #       should delegate_method(:deliver).to(:post_office).as(:ship)
       #     end
       #
+      # ##### with_prefix
+      #
+      # Use `with_prefix` when using Rails's `delegate` helper along with the
+      # `:prefix` option.
+      #
+      #     class Page < ActiveRecord::Base
+      #       belongs_to :site
+      #       delegate :name, to: :site, prefix: true
+      #       delegate :title, to: :site, prefix: :root
+      #     end
+      #
+      #     # RSpec
+      #     describe Page do
+      #       it { should delegate_method(:name).to(:site).with_prefix }
+      #       it { should delegate_method(:name).to(:site).with_prefix(true) }
+      #       it { should delegate_method(:title).to(:site).with_prefix(:root) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PageTest < Test::Unit::TestCase
+      #       should delegate_method(:name).to(:site).with_prefix
+      #       should delegate_method(:name).to(:site).with_prefix(true)
+      #       should delegate_method(:title).to(:site).with_prefix(:root)
+      #     end
+      #
       # ##### with_arguments
       #
       # Use `with_arguments` to assert that the delegate method is called with
@@ -108,56 +148,60 @@ module Shoulda
       # @return [DelegateMethodMatcher]
       #
       def delegate_method(delegating_method)
-        DelegateMethodMatcher.new(delegating_method, self)
+        DelegateMethodMatcher.new(delegating_method).in_context(self)
       end
 
       # @private
       class DelegateMethodMatcher
-        def initialize(delegating_method, context)
+        def initialize(delegating_method)
           @delegating_method = delegating_method
-          @context = context
 
-          @method_on_target = @delegating_method
-          @target_double = Doublespeak::ObjectDouble.new
+          @delegate_method = @delegating_method
+          @delegate_object = Doublespeak::ObjectDouble.new
 
           @delegated_arguments = []
-          @target_method = nil
+          @delegate_object_reader_method = nil
           @subject = nil
           @subject_double_collection = nil
         end
 
+        def in_context(context)
+          @context = MatcherContext.new(context)
+          self
+        end
+
         def matches?(subject)
           @subject = subject
 
-          ensure_target_method_is_present!
+          ensure_delegate_object_has_been_specified!
 
           subject_has_delegating_method? &&
-            subject_has_target_method? &&
-            subject_delegates_to_target_correctly?
+            subject_has_delegate_object_reader_method? &&
+            subject_delegates_to_delegate_object_correctly?
         end
 
         def description
           string = "delegate #{formatted_delegating_method_name} to " +
-            "#{formatted_target_method_name} object"
+            "#{formatted_delegate_object_reader_method_name} object"
 
           if delegated_arguments.any?
             string << " passing arguments #{delegated_arguments.inspect}"
           end
 
-          if method_on_target != delegating_method
-            string << " as #{formatted_method_on_target}"
+          if delegate_method != delegating_method
+            string << " as #{formatted_delegate_method}"
           end
 
           string
         end
 
-        def to(target_method)
-          @target_method = target_method
+        def to(delegate_object_reader_method)
+          @delegate_object_reader_method = delegate_object_reader_method
           self
         end
 
-        def as(method_on_target)
-          @method_on_target = method_on_target
+        def as(delegate_method)
+          @delegate_method = delegate_method
           self
         end
 
@@ -166,11 +210,25 @@ module Shoulda
           self
         end
 
+        def with_prefix(prefix = nil)
+          @delegating_method =
+            :"#{build_delegating_method_prefix(prefix)}_#{delegate_method}"
+            delegate_method
+          self
+        end
+
+        def build_delegating_method_prefix(prefix)
+          case prefix
+            when true, nil then delegate_object_reader_method
+            else prefix
+          end
+        end
+
         def failure_message
           "Expected #{class_under_test} to #{description}\n" +
             "Method calls sent to " +
-            "#{formatted_target_method_name(include_module: true)}:" +
-            formatted_calls_on_target
+            "#{formatted_delegate_object_reader_method_name(include_module: true)}:" +
+            formatted_calls_on_delegate_object
         end
         alias failure_message_for_should failure_message
 
@@ -186,33 +244,41 @@ module Shoulda
           :delegated_arguments,
           :delegating_method,
           :method,
-          :method_on_target,
+          :delegate_method,
           :subject_double_collection,
-          :target_double,
-          :target_method
+          :delegate_object,
+          :delegate_object_reader_method
 
         def subject
-          @subject || context.subject
+          @subject
+        end
+
+        def subject_is_a_class?
+          if @subject
+            @subject.is_a?(Class)
+          else
+            context.subject_is_a_class?
+          end
         end
 
         def class_under_test
-          if subject.is_a?(Class)
+          if subject_is_a_class?
             subject
           else
             subject.class
           end
         end
 
-        def formatted_method_on_target(options = {})
-          formatted_method_name_for(method_on_target, options)
+        def formatted_delegate_method(options = {})
+          formatted_method_name_for(delegate_method, options)
         end
 
         def formatted_delegating_method_name(options = {})
           formatted_method_name_for(delegating_method, options)
         end
 
-        def formatted_target_method_name(options = {})
-          formatted_method_name_for(target_method, options)
+        def formatted_delegate_object_reader_method_name(options = {})
+          formatted_method_name_for(delegate_object_reader_method, options)
         end
 
         def formatted_method_name_for(method_name, options)
@@ -230,19 +296,19 @@ module Shoulda
         end
 
         def class_or_instance_method_indicator
-          if subject.is_a?(Class)
+          if subject_is_a_class?
             '.'
           else
             '#'
           end
         end
 
-        def target_received_method?
-          calls_to_method_on_target.any?
+        def delegate_object_received_call?
+          calls_to_delegate_method.any?
         end
 
-        def target_received_method_with_delegated_arguments?
-          calls_to_method_on_target.any? do |call|
+        def delegate_object_received_call_with_delegated_arguments?
+          calls_to_delegate_method.any? do |call|
             call.args == delegated_arguments
           end
         end
@@ -251,17 +317,17 @@ module Shoulda
           subject.respond_to?(delegating_method)
         end
 
-        def subject_has_target_method?
-          subject.respond_to?(target_method, true)
+        def subject_has_delegate_object_reader_method?
+          subject.respond_to?(delegate_object_reader_method, true)
         end
 
-        def ensure_target_method_is_present!
-          if target_method.to_s.empty?
-            raise TargetNotDefinedError
+        def ensure_delegate_object_has_been_specified!
+          if delegate_object_reader_method.to_s.empty?
+            raise DelegateObjectNotSpecified
           end
         end
 
-        def subject_delegates_to_target_correctly?
+        def subject_delegates_to_delegate_object_correctly?
           register_subject_double_collection
 
           Doublespeak.with_doubles_activated do
@@ -269,35 +335,35 @@ module Shoulda
           end
 
           if delegated_arguments.any?
-            target_received_method_with_delegated_arguments?
+            delegate_object_received_call_with_delegated_arguments?
           else
-            target_received_method?
+            delegate_object_received_call?
           end
         end
 
         def register_subject_double_collection
           double_collection =
             Doublespeak.double_collection_for(subject.singleton_class)
-          double_collection.register_stub(target_method).
-            to_return(target_double)
+          double_collection.register_stub(delegate_object_reader_method).
+            to_return(delegate_object)
 
           @subject_double_collection = double_collection
         end
 
-        def calls_to_method_on_target
-          target_double.calls_to(method_on_target)
+        def calls_to_delegate_method
+          delegate_object.calls_to(delegate_method)
         end
 
-        def calls_on_target
-          target_double.calls
+        def calls_on_delegate_object
+          delegate_object.calls
         end
 
-        def formatted_calls_on_target
+        def formatted_calls_on_delegate_object
           string = ""
 
-          if calls_on_target.any?
+          if calls_on_delegate_object.any?
             string << "\n"
-            calls_on_target.each_with_index do |call, i|
+            calls_on_delegate_object.each_with_index do |call, i|
               name = call.method_name
               args = call.args.map { |arg| arg.inspect }.join(', ')
               string << "#{i+1}) #{name}(#{args})\n"

data/lib/shoulda/matchers/independent/delegate_method_matcher/target_not_defined_error.rb

@@ -3,7 +3,7 @@ module Shoulda
     module Independent
       class DelegateMethodMatcher
         # @private
-        class TargetNotDefinedError < StandardError
+        class DelegateObjectNotSpecified < StandardError
           def message
             'Delegation needs a target. Use the #to method to define one, e.g.
             `post_office.should delegate(:deliver_mail).to(:mailman)`'.squish

data/lib/shoulda/matchers/matcher_context.rb

@@ -0,0 +1,35 @@
+module Shoulda
+  module Matchers
+    class MatcherContext
+      def initialize(context)
+        @context = context
+      end
+
+      def subject_is_a_class?
+        if inside_a_shoulda_context_project? && outside_a_should_block?
+          assume_that_subject_is_not_a_class
+        else
+          context.subject.is_a?(Class)
+        end
+      end
+
+      protected
+
+      attr_reader :context
+
+      private
+
+      def inside_a_shoulda_context_project?
+        defined?(Shoulda::Context)
+      end
+
+      def outside_a_should_block?
+        context.is_a?(Class)
+      end
+
+      def assume_that_subject_is_not_a_class
+        false
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/rails_shim.rb

@@ -42,6 +42,29 @@ module Shoulda
         end
       end
 
+      def self.type_cast_default_for(model, column)
+        if model.respond_to?(:column_defaults)
+          # Rails 4.2
+          model.column_defaults[column.name]
+        else
+          column.default
+        end
+      end
+
+      def self.serialized_attributes_for(model)
+        if defined?(::ActiveRecord::Type::Serialized)
+          # Rails 5+
+          model.columns.select do |column|
+            column.cast_type.is_a?(::ActiveRecord::Type::Serialized)
+          end.inject({}) do |hash, column|
+            hash[column.name.to_s] = column.cast_type.coder
+            hash
+          end
+        else
+          model.serialized_attributes
+        end
+      end
+
       def self.active_record_major_version
         ::ActiveRecord::VERSION::MAJOR
       end

data/lib/shoulda/matchers/util.rb

@@ -0,0 +1,28 @@
+module Shoulda
+  module Matchers
+    # @private
+    module Util
+      def self.deconstantize(path)
+        if defined?(ActiveSupport::Inflector) &&
+          ActiveSupport::Inflector.respond_to?(:deconstantize)
+          ActiveSupport::Inflector.deconstantize(path)
+        else
+          path.to_s[0...(path.to_s.rindex('::') || 0)]
+        end
+      end
+
+      def self.safe_constantize(camel_cased_word)
+        if defined?(ActiveSupport::Inflector) &&
+          ActiveSupport::Inflector.respond_to?(:safe_constantize)
+          ActiveSupport::Inflector.safe_constantize(camel_cased_word)
+        else
+          begin
+            camel_cased_word.constantize
+          rescue NameError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '2.7.0'.freeze
+    VERSION = '2.8.0.rc1'.freeze
   end
 end

data/script/SUPPORTED_VERSIONS

@@ -1 +1 @@
-1.9.2 1.9.3 2.0.0 2.1.1
+1.9.2 1.9.3 2.0.0 2.1.5

data/spec/acceptance/active_model_integration_spec.rb

@@ -0,0 +1,20 @@
+require 'acceptance_spec_helper'
+
+describe 'shoulda-matchers integrates with an ActiveModel project' do
+  specify 'and loads without errors' do
+    create_active_model_project
+
+    add_shoulda_matchers_to_project
+
+    write_file 'load_dependencies.rb', <<-FILE
+      require 'active_model'
+      require 'shoulda-matchers'
+
+      puts ActiveModel::VERSION::STRING
+      puts "Loaded all dependencies without errors"
+    FILE
+
+    result = run_command_within_bundle('ruby load_dependencies.rb')
+    expect(result).to have_output('Loaded all dependencies without errors')
+  end
+end