shoulda-matchers 4.0.0.rc1 → 4.0.1

data/spec/support/unit/matchers/fail_with_message_including_matcher.rb

@@ -1,51 +0,0 @@
-module UnitTests
-  module Matchers
-    extend RSpec::Matchers::DSL
-
-    matcher :fail_with_message_including do |expected|
-      def supports_block_expectations?
-        true
-      end
-
-      match do |block|
-        @actual = nil
-
-        begin
-          block.call
-        rescue RSpec::Expectations::ExpectationNotMetError => ex
-          @actual = ex.message
-        end
-
-        @actual && @actual.include?(expected)
-      end
-
-      def failure_message
-        lines = ['Expectation should have failed with message including:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-
-        if @actual
-          lines << 'The full message was:'
-          lines << Shoulda::Matchers::Util.indent(@actual, 2)
-        else
-          lines << 'However, the expectation did not fail at all.'
-        end
-
-        lines.join("\n")
-      end
-
-      def failure_message_for_should
-        failure_message
-      end
-
-      def failure_message_when_negated
-        lines = ['Expectation should not have failed with message including:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-        lines.join("\n")
-      end
-
-      def failure_message_for_should_not
-        failure_message_when_negated
-      end
-    end
-  end
-end

data/spec/support/unit/matchers/fail_with_message_matcher.rb

@@ -1,64 +0,0 @@
-module UnitTests
-  module Matchers
-    extend RSpec::Matchers::DSL
-
-    matcher :fail_with_message do |expected|
-      def supports_block_expectations?
-        true
-      end
-
-      match do |block|
-        @actual = nil
-
-        begin
-          block.call
-        rescue RSpec::Expectations::ExpectationNotMetError => ex
-          @actual = ex.message
-        end
-
-        @actual && @actual == expected.sub(/\n\z/, '')
-      end
-
-      def failure_message
-        lines = ['Expectation should have failed with message:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-
-        if @actual
-          diff = differ.diff(@actual, expected)[1..-1]
-
-          lines << 'Actually failed with:'
-          lines << Shoulda::Matchers::Util.indent(@actual, 2)
-
-          if diff
-            lines << 'Diff:'
-            lines << Shoulda::Matchers::Util.indent(diff, 2)
-          end
-        else
-          lines << 'However, the expectation did not fail at all.'
-        end
-
-        lines.join("\n")
-      end
-
-      def failure_message_for_should
-        failure_message
-      end
-
-      def failure_message_when_negated
-        lines = ['Expectation should not have failed with message:']
-        lines << Shoulda::Matchers::Util.indent(expected, 2)
-        lines.join("\n")
-      end
-
-      def failure_message_for_should_not
-        failure_message_when_negated
-      end
-
-      private
-
-      def differ
-        @_differ ||= RSpec::Support::Differ.new
-      end
-    end
-  end
-end

data/spec/support/unit/matchers/print_warning_including.rb

@@ -1,67 +0,0 @@
-module UnitTests
-  module Matchers
-    def print_warning_including(expected_warning)
-      PrintWarningIncludingMatcher.new(expected_warning)
-    end
-
-    class PrintWarningIncludingMatcher
-      def initialize(expected_warning)
-        @expected_warning = collapse_whitespace(expected_warning)
-      end
-
-      def matches?(block)
-        @captured_stderr = collapse_whitespace(capture(:stderr, &block))
-        @was_negated = false
-        captured_stderr.include?(expected_warning)
-      end
-
-      def does_not_match?(block)
-        !matches?(block).tap do
-          @was_negated = true
-        end
-      end
-
-      def failure_message
-        "Expected block to #{expectation}\n\nHowever, #{aberration}"
-      end
-
-      def failure_message_when_negated
-        "Expected block not to #{expectation}\n\nHowever, #{aberration}"
-      end
-
-      def description
-        "should print a warning containing #{expected_warning.inspect}"
-      end
-
-      def supports_block_expectations?
-        true
-      end
-
-      private
-
-      attr_reader :expected_warning, :captured_stderr
-
-      def was_negated?
-        @was_negated
-      end
-
-      def expectation
-        "print a warning containing:\n\n  #{expected_warning}"
-      end
-
-      def aberration
-        if was_negated?
-          'it did.'
-        elsif captured_stderr.empty?
-          'it actually printed nothing.'
-        else
-          "it actually printed:\n\n  #{captured_stderr}"
-        end
-      end
-
-      def collapse_whitespace(string)
-        string.gsub(/\n+/, ' ').squeeze(' ')
-      end
-    end
-  end
-end

data/spec/support/unit/model_creation_strategies/active_model.rb

@@ -1,111 +0,0 @@
-module UnitTests
-  module ModelCreationStrategies
-    class ActiveModel
-      def self.call(name, columns = {}, options = {}, &block)
-        new(name, columns, options, &block).call
-      end
-
-      def initialize(name, columns = {}, options = {}, &block)
-        @name = name
-        @columns = columns
-        @options = options
-        @model_customizers = []
-
-        if block
-          customize_model(&block)
-        end
-      end
-
-      def customize_model(&block)
-        model_customizers << block
-      end
-
-      def call
-        ClassBuilder.define_class(name, Model).tap do |model|
-          model.columns = columns.keys
-
-          model_customizers.each do |block|
-            run_block(model, block)
-          end
-        end
-      end
-
-      protected
-
-      attr_reader :name, :columns, :model_customizers, :options
-
-      private
-
-      def run_block(model, block)
-        if block
-          if block.arity == 0
-            model.class_eval(&block)
-          else
-            block.call(model)
-          end
-        end
-      end
-
-      class Model
-        class << self
-          def columns
-            @_columns ||= []
-          end
-
-          def columns=(columns)
-            existing_columns = self.columns
-            new_columns = columns - existing_columns
-
-            @_columns += new_columns
-
-            include attributes_module
-
-            attributes_module.module_eval do
-              new_columns.each do |column|
-                define_method(column) do
-                  attributes[column]
-                end
-
-                define_method("#{column}=") do |value|
-                  attributes[column] = value
-                end
-              end
-            end
-          end
-
-          private
-
-          def attributes_module
-            @_attributes_module ||= Module.new
-          end
-        end
-
-        include ::ActiveModel::Model
-
-        attr_reader :attributes
-
-        def initialize(attributes = {})
-          @attributes = attributes.symbolize_keys
-        end
-
-        def inspect
-          middle = '%s:0x%014x%s' % [
-            self.class,
-            object_id * 2,
-            ' ' + inspected_attributes.join(' ')
-          ]
-
-          "#<#{middle.strip}>"
-        end
-
-        private
-
-        def inspected_attributes
-          self.class.columns.map do |key, value|
-            "#{key}: #{attributes[key].inspect}"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/unit/model_creation_strategies/active_record.rb

@@ -1,77 +0,0 @@
-module UnitTests
-  module ModelCreationStrategies
-    class ActiveRecord
-      def self.call(name, columns = {}, options = {}, &block)
-        new(name, columns, options, &block).call
-      end
-
-      def initialize(name, columns = {}, options = {}, &block)
-        @name = name
-        @columns = columns
-        @options = options
-        @model_customizers = []
-
-        if block
-          customize_model(&block)
-        end
-      end
-
-      def customize_model(&block)
-        model_customizers << block
-      end
-
-      def call
-        create_table_for_model
-        define_class_for_model
-      end
-
-      protected
-
-      attr_reader :columns, :model_customizers, :name, :options
-
-      private
-
-      def create_table_for_model
-        UnitTests::ActiveRecord::CreateTable.call(table_name, columns)
-      end
-
-      def define_class_for_model
-        model = UnitTests::ModelBuilder.define_model_class(class_name)
-
-        model_customizers.each do |block|
-          run_block(model, block)
-        end
-
-        if whitelist_attributes? && model.respond_to?(:attr_accessible)
-          model.attr_accessible(*columns.keys)
-        end
-
-        model.table_name = table_name
-
-        model
-      end
-
-      def run_block(model, block)
-        if block
-          if block.arity == 0
-            model.class_eval(&block)
-          else
-            block.call(model)
-          end
-        end
-      end
-
-      def class_name
-        name.to_s.pluralize.classify
-      end
-
-      def table_name
-        class_name.tableize.gsub('/', '_')
-      end
-
-      def whitelist_attributes?
-        options.fetch(:whitelist_attributes, true)
-      end
-    end
-  end
-end

data/spec/support/unit/model_creators.rb

@@ -1,19 +0,0 @@
-module UnitTests
-  module ModelCreators
-    class << self
-      def register(name, klass)
-        registrations[name] = klass
-      end
-
-      def retrieve(name)
-        registrations[name]
-      end
-
-      private
-
-      def registrations
-        @_registrations ||= {}
-      end
-    end
-  end
-end

data/spec/support/unit/model_creators/active_model.rb

@@ -1,39 +0,0 @@
-require_relative '../model_creators'
-require 'forwardable'
-
-module UnitTests
-  module ModelCreators
-    class ActiveModel
-      def self.call(args)
-        new(args).call
-      end
-
-      extend Forwardable
-
-      def_delegators(
-        :arguments,
-        :attribute_name,
-        :attribute_default_values_by_name,
-      )
-
-      def initialize(args)
-        @arguments = CreateModelArguments::Basic.wrap(
-          args.merge(
-            model_creation_strategy: UnitTests::ModelCreationStrategies::ActiveModel
-          )
-        )
-        @model_creator = Basic.new(arguments)
-      end
-
-      def call
-        model_creator.call
-      end
-
-      protected
-
-      attr_reader :arguments, :model_creator
-    end
-
-    register(:active_model, ActiveModel)
-  end
-end

data/spec/support/unit/model_creators/active_record.rb

@@ -1,42 +0,0 @@
-require_relative '../model_creators'
-require 'forwardable'
-
-module UnitTests
-  module ModelCreators
-    class ActiveRecord
-      def self.call(args)
-        new(args).call
-      end
-
-      extend Forwardable
-
-      def_delegators(
-        :arguments,
-        :attribute_default_values_by_name,
-        :attribute_name,
-        :model_name,
-      )
-
-      def_delegators :model_creator, :customize_model
-
-      def initialize(args)
-        @arguments = CreateModelArguments::Basic.wrap(
-          args.merge(
-            model_creation_strategy: UnitTests::ModelCreationStrategies::ActiveRecord
-          )
-        )
-        @model_creator = Basic.new(arguments)
-      end
-
-      def call
-        model_creator.call
-      end
-
-      protected
-
-      attr_reader :arguments, :model_creator
-    end
-
-    register(:active_record, ActiveRecord)
-  end
-end