shoulda-matchers 4.0.0.rc1 → 4.0.1

data/spec/support/unit/create_model_arguments/basic.rb

@@ -1,135 +0,0 @@
-require 'forwardable'
-
-module UnitTests
-  module CreateModelArguments
-    class Basic
-      DEFAULT_MODEL_NAME = 'Example'
-      DEFAULT_ATTRIBUTE_NAME = :attr
-      DEFAULT_COLUMN_TYPE = :string
-
-      def self.wrap(args)
-        if args.is_a?(self)
-          args
-        else
-          new(args)
-        end
-      end
-
-      extend Forwardable
-
-      def_delegators(
-        :attribute,
-        :column_type,
-        :column_options,
-        :default_value,
-        :value_type
-      )
-
-      def initialize(args)
-        @args = args
-      end
-
-      def fetch(*args, &block)
-        self.args.fetch(*args, &block)
-      end
-
-      def merge(given_args)
-        self.class.new(args.deep_merge(given_args))
-      end
-
-      def model_name
-        args.fetch(:model_name, DEFAULT_MODEL_NAME)
-      end
-
-      def attribute_name
-        args.fetch(:attribute_name, default_attribute_name)
-      end
-
-      def model_creation_strategy
-        args.fetch(:model_creation_strategy)
-      end
-
-      def columns
-        { attribute_name => column_options }
-      end
-
-      def attribute
-        @_attribute ||= attribute_class.new(attribute_args)
-      end
-
-      def all_attribute_overrides
-        @_all_attribute_overrides ||= begin
-          attribute_overrides = args.slice(
-            :changing_values_with,
-            :default_value
-          )
-
-          overrides =
-            if attribute_overrides.empty?
-              {}
-            else
-              { attribute_name => attribute_overrides }
-            end
-
-          overrides.deep_merge(args.fetch(:attribute_overrides, {}))
-        end
-      end
-
-      def attribute_overrides
-        all_attribute_overrides.fetch(attribute_name, {})
-      end
-
-      def validation_name
-        args.fetch(:validation_name) { map_matcher_name_to_validation_name }
-      end
-
-      def validation_options
-        args.fetch(:validation_options, {})
-      end
-
-      def custom_validation?
-        args.fetch(:custom_validation, false)
-      end
-
-      def matcher_name
-        args.fetch(:matcher_name)
-      end
-
-      def attribute_default_values_by_name
-        if attribute_overrides.key?(:default_value)
-          { attribute_name => attribute_overrides[:default_value] }
-        else
-          {}
-        end
-      end
-
-      def to_hash
-        args.deep_dup
-      end
-
-      protected
-
-      attr_reader :args
-
-      def attribute_class
-        UnitTests::Attribute
-      end
-
-      def default_attribute_name
-        DEFAULT_ATTRIBUTE_NAME
-      end
-
-      private
-
-      def map_matcher_name_to_validation_name
-        matcher_name.to_s.sub('validate', 'validates')
-      end
-
-      def attribute_args
-        args.slice(:column_type).deep_merge(
-          attribute_overrides.deep_merge(name: attribute_name)
-        )
-      end
-    end
-  end
-end

data/spec/support/unit/create_model_arguments/has_many.rb

@@ -1,15 +0,0 @@
-module UnitTests
-  module CreateModelArguments
-    class HasMany < Basic
-      def columns
-        super.except(attribute_name)
-      end
-
-      private
-
-      def default_attribute_name
-        :children
-      end
-    end
-  end
-end

data/spec/support/unit/create_model_arguments/uniqueness_matcher.rb

@@ -1,74 +0,0 @@
-module UnitTests
-  module CreateModelArguments
-    class UniquenessMatcher < Basic
-      def self.normalize_attribute(attribute)
-        if attribute.is_a?(Hash)
-          Attribute.new(attribute)
-        else
-          Attribute.new(name: attribute)
-        end
-      end
-
-      def self.normalize_attributes(attributes)
-        attributes.map do |attribute|
-          normalize_attribute(attribute)
-        end
-      end
-
-      def columns
-        attributes.reduce({}) do |options, attribute|
-          options.merge(
-            attribute.name => {
-              type: attribute.column_type,
-              options: attribute.column_options
-            }
-          )
-        end
-      end
-
-      def validation_options
-        super.merge(scope: scope_attribute_names)
-      end
-
-      def attribute_default_values_by_name
-        attributes.reduce({}) do |values, attribute|
-          values.merge(attribute.name => attribute.default_value)
-        end
-      end
-
-      protected
-
-      def attribute_class
-        Attribute
-      end
-
-      private
-
-      def attributes
-        [attribute] + scope_attributes + additional_attributes
-      end
-
-      def scope_attribute_names
-        scope_attributes.map(&:name)
-      end
-
-      def scope_attributes
-        @_scope_attributes ||= self.class.normalize_attributes(
-          args.fetch(:scopes, [])
-        )
-      end
-
-      def additional_attributes
-        @_additional_attributes ||= self.class.normalize_attributes(
-          args.fetch(:additional_attributes, [])
-        )
-      end
-
-      class Attribute < UnitTests::Attribute
-        def value_type
-          args.fetch(:value_type) { column_type }
-        end
-      end
-    end
-  end
-end

data/spec/support/unit/helpers/action_pack_versions.rb

@@ -1,22 +0,0 @@
-module UnitTests
-  module ActionPackVersions
-    extend self
-
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-      example_group.extend(self)
-    end
-
-    def action_pack_gte_5?
-      action_pack_version >= 5
-    end
-
-    def action_pack_lt_5?
-      action_pack_version < 5
-    end
-
-    def action_pack_version
-      Tests::Version.new(ActionPack::VERSION::STRING)
-    end
-  end
-end

data/spec/support/unit/helpers/active_model_helpers.rb

@@ -1,27 +0,0 @@
-module UnitTests
-  module ActiveModelHelpers
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-    end
-
-    def custom_validation(options = {}, &block)
-      attribute_name = options.fetch(:attribute_name, :attr)
-      attribute_type = options.fetch(:attribute_type, :integer)
-      column_options = options.fetch(:column_options, {})
-      attribute_options = { type: attribute_type, options: column_options }
-
-      define_model(:example, attribute_name => attribute_options) do
-        validate :custom_validation
-
-        define_method(:custom_validation, &block)
-      end.new
-    end
-    alias record_with_custom_validation custom_validation
-
-    def validating_format(options)
-      define_model :example, attr: :string do
-        validates_format_of :attr, options
-      end.new
-    end
-  end
-end

data/spec/support/unit/helpers/active_model_versions.rb

@@ -1,32 +0,0 @@
-module UnitTests
-  module ActiveModelVersions
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-      example_group.extend(self)
-    end
-
-    def active_model_version
-      Tests::Version.new(::ActiveModel::VERSION::STRING)
-    end
-
-    def active_model_3_1?
-      (::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1) || active_model_4_0?
-    end
-
-    def active_model_3_2?
-      (::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 2) || active_model_4_0?
-    end
-
-    def active_model_4_0?
-      ::ActiveModel::VERSION::MAJOR == 4
-    end
-
-    def active_model_supports_absence_validation?
-      active_model_version >= 4
-    end
-
-    def active_model_supports_strict?
-      active_model_version >= 3.2
-    end
-  end
-end

data/spec/support/unit/helpers/active_record_versions.rb

@@ -1,44 +0,0 @@
-module UnitTests
-  module ActiveRecordVersions
-    def self.configure_example_group(example_group)
-      example_group.include(self)
-      example_group.extend(self)
-    end
-
-    def active_record_version
-      Tests::Version.new(::ActiveRecord::VERSION::STRING)
-    end
-
-    def active_record_enum_supports_prefix_and_suffix?
-      active_record_version >= 5
-    end
-
-    def active_record_supports_has_secure_password?
-      active_record_version >= 3.1
-    end
-
-    def active_record_supports_has_secure_token?
-      active_record_version >= 5.0
-    end
-
-    def active_record_supports_array_columns?
-      active_record_version > 4.2
-    end
-
-    def active_record_supports_relations?
-      active_record_version >= 4
-    end
-
-    def active_record_supports_more_dependent_options?
-      active_record_version >= 4
-    end
-
-    def active_record_uniqueness_supports_array_columns?
-      active_record_version < 5
-    end
-
-    def active_record_supports_optional_for_associations?
-      active_record_version >= 5
-    end
-  end
-end

data/spec/support/unit/helpers/active_resource_builder.rb

@@ -1,27 +0,0 @@
-module UnitTests
-  module ActiveResourceBuilder
-    def self.configure_example_group(example_group)
-      require 'active_resource'
-
-      example_group.include ActiveResourceBuilder
-
-      example_group.after do
-        ActiveSupport::Dependencies.clear
-      end
-    end
-
-    def define_active_resource_class(class_name, attributes = {}, &block)
-      define_class(class_name, ActiveResource::Base) do
-        schema do
-          attributes.each do |attr, type|
-            attribute attr, type
-          end
-        end
-
-        if block_given?
-          class_eval(&block)
-        end
-      end
-    end
-  end
-end

data/spec/support/unit/helpers/allow_value_matcher_helpers.rb

@@ -1,15 +0,0 @@
-require_relative '../record_with_different_error_attribute_builder'
-require_relative '../record_builder_with_i18n_validation_message'
-
-module UnitTests
-  module AllowValueMatcherHelpers
-    def builder_for_record_with_different_error_attribute(options = {})
-      RecordWithDifferentErrorAttributeBuilder.new(options)
-    end
-
-    def builder_for_record_with_different_error_attribute_using_i18n(options = {})
-      builder = builder_for_record_with_different_error_attribute(options)
-      RecordBuilderWithI18nValidationMessage.new(builder)
-    end
-  end
-end

data/spec/support/unit/helpers/class_builder.rb

@@ -1,90 +0,0 @@
-module UnitTests
-  module ClassBuilder
-    def define_module(*args, &block)
-      ClassBuilder.define_module(*args, &block)
-    end
-
-    def define_class(*args, &block)
-      ClassBuilder.define_class(*args, &block)
-    end
-
-    class << self
-      def configure_example_group(example_group)
-        example_group.include(self)
-
-        example_group.after do
-          ClassBuilder.reset
-        end
-      end
-
-      def reset
-        remove_defined_classes
-      end
-
-      def define_module(module_name, &block)
-        module_name = module_name.to_s.camelize
-
-        namespace, name_without_namespace =
-          ClassBuilder.parse_constant_name(module_name)
-
-        if namespace.const_defined?(name_without_namespace, false)
-          namespace.__send__(:remove_const, name_without_namespace)
-        end
-
-        eval <<-RUBY
-          module #{namespace}::#{name_without_namespace}
-          end
-        RUBY
-
-        namespace.const_get(name_without_namespace).tap do |constant|
-          constant.unloadable
-
-          if block
-            constant.module_eval(&block)
-          end
-        end
-      end
-
-      def define_class(class_name, parent_class = Object, &block)
-        class_name = class_name.to_s.camelize
-
-        namespace, name_without_namespace =
-          ClassBuilder.parse_constant_name(class_name)
-
-        if namespace.const_defined?(name_without_namespace, false)
-          namespace.__send__(:remove_const, name_without_namespace)
-        end
-
-        eval <<-RUBY
-          class #{namespace}::#{name_without_namespace} < ::#{parent_class}
-          end
-        RUBY
-
-        namespace.const_get(name_without_namespace).tap do |constant|
-          constant.unloadable
-
-          if block
-            if block.arity == 0
-              constant.class_eval(&block)
-            else
-              block.call(constant)
-            end
-          end
-        end
-      end
-
-      def parse_constant_name(name)
-        namespace = Shoulda::Matchers::Util.deconstantize(name)
-        qualified_namespace = (namespace.presence || 'Object').constantize
-        name_without_namespace = name.to_s.demodulize
-        [qualified_namespace, name_without_namespace]
-      end
-
-      private
-
-      def remove_defined_classes
-        ::ActiveSupport::Dependencies.clear
-      end
-    end
-  end
-end