ultra-fast-box 0.0.1

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/counter_cache_matcher.rb

@@ -0,0 +1,74 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class CounterCacheMatcher
+          attr_accessor :missing_option
+
+          def initialize(counter_cache, name)
+            @counter_cache = counter_cache
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "counter_cache => #{counter_cache}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if correct_value?
+              true
+            else
+              self.missing_option = "#{name} should have #{description}"
+              false
+            end
+          end
+
+          protected
+
+          attr_accessor :subject, :counter_cache, :name
+
+          def correct_value?
+            expected = normalize_value
+
+            if expected.is_a?(Hash)
+              option_verifier.correct_for_hash?(
+                :counter_cache,
+                expected,
+              )
+            else
+              option_verifier.correct_for_string?(
+                :counter_cache,
+                expected,
+              )
+            end
+          end
+
+          def option_verifier
+            @_option_verifier ||= OptionVerifier.new(subject)
+          end
+
+          def normalize_value
+            if Rails::VERSION::STRING >= '7.2'
+              case counter_cache
+              when true
+                { active: true, column: nil }
+              when String, Symbol
+                { active: true, column: counter_cache.to_s }
+              when Hash
+                { active: true, column: nil }.merge!(counter_cache)
+              else
+                raise ArgumentError, 'Invalid counter_cache option'
+              end
+            else
+              counter_cache
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/dependent_matcher.rb

@@ -0,0 +1,62 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class DependentMatcher
+          attr_accessor :missing_option
+
+          def initialize(dependent, name)
+            @dependent = dependent
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "dependent => #{dependent}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_matches?
+              true
+            else
+              self.missing_option = generate_missing_option
+              false
+            end
+          end
+
+          protected
+
+          attr_accessor :subject, :dependent, :name
+
+          private
+
+          def option_verifier
+            @_option_verifier ||= OptionVerifier.new(subject)
+          end
+
+          def option_matches?
+            option_verifier.correct_for?(option_type, :dependent, dependent)
+          end
+
+          def option_type
+            case dependent
+            when true, false then :boolean
+            else :string
+            end
+          end
+
+          def generate_missing_option
+            [
+              "#{name} should have",
+              (dependent == true ? 'a' : dependent),
+              'dependency',
+            ].join(' ')
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/inverse_of_matcher.rb

@@ -0,0 +1,41 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class InverseOfMatcher
+          attr_accessor :missing_option
+
+          def initialize(inverse_of, name)
+            @inverse_of = inverse_of
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "inverse_of => #{inverse_of}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_verifier.correct_for_string?(:inverse_of, inverse_of)
+              true
+            else
+              self.missing_option = "#{name} should have #{description}"
+              false
+            end
+          end
+
+          protected
+
+          attr_accessor :subject, :inverse_of, :name
+
+          def option_verifier
+            @_option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/join_table_matcher.rb

@@ -0,0 +1,105 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class JoinTableMatcher
+          attr_reader :failure_message
+
+          alias :missing_option :failure_message
+
+          delegate :model_class, :join_table_name, :associated_class, :options,
+            :name, :option_verifier, to: :association_matcher
+
+          delegate :connection, to: :model_class
+
+          def initialize(association_matcher, reflector)
+            @association_matcher = association_matcher
+            @reflector = reflector
+          end
+
+          def matches?(_subject)
+            join_table_option_correct? &&
+              join_table_exists? &&
+              join_table_has_correct_columns?
+          end
+
+          def join_table_option_correct?
+            if options.key?(:join_table_name)
+              if option_verifier.correct_for_string?(
+                :join_table,
+                options[:join_table_name],
+              )
+                true
+              else
+                @failure_message = "#{name} should use"\
+                  " #{options[:join_table_name].inspect} for :join_table option"
+                false
+              end
+            else
+              true
+            end
+          end
+
+          def join_table_exists?
+            if connection.data_sources.
+                include?(join_table_name.to_s)
+              true
+            else
+              @failure_message = missing_table_message
+              false
+            end
+          end
+
+          def join_table_has_correct_columns?
+            if missing_columns.empty?
+              true
+            else
+              @failure_message = missing_columns_message
+              false
+            end
+          end
+
+          protected
+
+          attr_reader :association_matcher, :reflector
+
+          private
+
+          delegate :foreign_key, :association_foreign_key, to: :reflector
+
+          def missing_columns
+            @_missing_columns ||= expected_join_table_columns.reject do |key|
+              actual_join_table_columns.include?(key.to_s)
+            end
+          end
+
+          def expected_join_table_columns
+            [foreign_key, association_foreign_key]
+          end
+
+          def actual_join_table_columns
+            connection.columns(join_table_name).map(&:name)
+          end
+
+          def missing_table_message
+            "join table #{join_table_name} doesn't exist"
+          end
+
+          def missing_columns_message
+            missing = missing_columns.join(', ')
+            "join table #{join_table_name} missing #{column_label}: #{missing}"
+          end
+
+          def column_label
+            if missing_columns.length > 1
+              'columns'
+            else
+              'column'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/model_reflection.rb

@@ -0,0 +1,101 @@
+require 'delegate'
+
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class ModelReflection < SimpleDelegator
+          def initialize(reflection)
+            super(reflection)
+            @reflection = reflection
+            @subject = reflection.active_record
+          end
+
+          def associated_class
+            if polymorphic?
+              subject
+            else
+              reflection.klass
+            end
+          end
+
+          def polymorphic?
+            reflection.options[:polymorphic]
+          end
+
+          def through?
+            reflection.options[:through]
+          end
+
+          def join_table_name
+            join_table_name =
+              has_and_belongs_to_many_name_table_name || reflection.join_table
+            join_table_name.to_s
+          end
+
+          def association_relation(related_instance)
+            relation = associated_class.all
+
+            if reflection.scope
+              # Source: AR::Associations::AssociationScope#eval_scope
+              relation.instance_exec(related_instance, &reflection.scope)
+            else
+              relation
+            end
+          end
+
+          def foreign_key
+            if has_and_belongs_to_many_reflection
+              has_and_belongs_to_many_reflection.foreign_key
+            elsif reflection.respond_to?(:foreign_key)
+              reflection.foreign_key
+            else
+              reflection.primary_key_name
+            end
+          end
+
+          def association_foreign_key
+            if has_and_belongs_to_many_reflection
+              join_model = has_and_belongs_to_many_reflection.options[:class]
+              join_model.right_reflection.foreign_key
+            else
+              reflection.association_foreign_key
+            end
+          end
+
+          def validate_inverse_of_through_association!
+            if through?
+              reflection.check_validity!
+            end
+          end
+
+          def has_and_belongs_to_many_name
+            reflection.options[:through]
+          end
+
+          def strict_loading?
+            reflection.options.fetch(:strict_loading, subject.strict_loading_by_default)
+          end
+
+          protected
+
+          attr_reader :reflection, :subject
+
+          private
+
+          def has_and_belongs_to_many_name_table_name
+            has_and_belongs_to_many_reflection&.table_name
+          end
+
+          def has_and_belongs_to_many_reflection
+            @_has_and_belongs_to_many_reflection ||=
+              if has_and_belongs_to_many_name
+                @subject.reflect_on_association(has_and_belongs_to_many_name)
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/model_reflector.rb

@@ -0,0 +1,89 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class ModelReflector
+          delegate(
+            :associated_class,
+            :association_foreign_key,
+            :foreign_key,
+            :foreign_type,
+            :has_and_belongs_to_many_name,
+            :join_table_name,
+            :polymorphic?,
+            :validate_inverse_of_through_association!,
+            to: :reflection,
+          )
+
+          delegate(
+            :through?,
+            to: :reflection,
+            allow_nil: true,
+          )
+
+          def initialize(subject, name)
+            @subject = subject
+            @name = name
+          end
+
+          def association_relation
+            reflection.association_relation(subject)
+          end
+
+          def reflection
+            @_reflection ||= reflect_on_association(name)
+          end
+
+          def reflect_on_association(name)
+            reflection = model_class.reflect_on_association(name)
+
+            if reflection
+              ModelReflection.new(reflection)
+            end
+          end
+
+          def model_class
+            subject.class
+          end
+
+          def build_relation_with_clause(name, value)
+            case name
+            when :conditions
+              associated_class.where(value)
+            when :order
+              associated_class.order(value)
+            else
+              raise ArgumentError, "Unknown clause '#{name}'"
+            end
+          end
+
+          def extract_relation_clause_from(relation, name)
+            case name
+            when :conditions
+              relation.where_values_hash
+            when :order
+              relation.order_values.map do |value|
+                value_as_sql(value)
+              end.join(', ')
+            else
+              raise ArgumentError, "Unknown clause '#{name}'"
+            end
+          end
+
+          protected
+
+          attr_reader :subject, :name
+
+          def value_as_sql(value)
+            if value.respond_to?(:to_sql)
+              value.to_sql
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/option_verifier.rb

@@ -0,0 +1,142 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class OptionVerifier
+          delegate :reflection, to: :reflector
+
+          DEFAULT_VALUE_OF_OPTIONS = {
+            has_many: {
+              validate: true,
+            },
+          }.freeze
+          RELATION_OPTIONS = [:conditions, :order].freeze
+
+          def initialize(reflector)
+            @reflector = reflector
+          end
+
+          def correct_for_string?(name, expected_value)
+            correct_for?(:string, name, expected_value)
+          end
+
+          def correct_for_boolean?(name, expected_value)
+            correct_for?(:boolean, name, expected_value)
+          end
+
+          def correct_for_hash?(name, expected_value)
+            correct_for?(:hash, name, expected_value)
+          end
+
+          def correct_for_constant?(name, expected_unresolved_value)
+            correct_for?(:constant, name, expected_unresolved_value)
+          end
+
+          def correct_for_relation_clause?(name, expected_value)
+            correct_for?(:relation_clause, name, expected_value)
+          end
+
+          def correct_for?(*args)
+            expected_value, name, type = args.reverse
+
+            if expected_value.nil?
+              true
+            else
+              type_cast_expected_value = type_cast(
+                type,
+                expected_value_for(type, name, expected_value),
+              )
+              actual_value = type_cast(type, actual_value_for(name))
+              type_cast_expected_value == actual_value
+            end
+          end
+
+          def actual_value_for(name)
+            if RELATION_OPTIONS.include?(name)
+              actual_value_for_relation_clause(name)
+            else
+              method_name = "actual_value_for_#{name}"
+              if respond_to?(method_name, true)
+                __send__(method_name)
+              else
+                actual_value_for_option(name)
+              end
+            end
+          end
+
+          protected
+
+          attr_reader :reflector
+
+          def type_cast(type, value)
+            case type
+            when :string, :relation_clause
+              value.to_s
+            when :boolean
+              !!value
+            when :hash
+              Hash(value).stringify_keys
+            else
+              value
+            end
+          end
+
+          def expected_value_for(type, name, value)
+            if RELATION_OPTIONS.include?(name)
+              expected_value_for_relation_clause(name, value)
+            elsif type == :constant
+              expected_value_for_constant(value)
+            else
+              value
+            end
+          end
+
+          def expected_value_for_relation_clause(name, value)
+            relation = reflector.build_relation_with_clause(name, value)
+            reflector.extract_relation_clause_from(relation, name)
+          end
+
+          def expected_value_for_constant(name)
+            namespace = Shoulda::Matchers::Util.deconstantize(
+              reflector.model_class.to_s,
+            )
+
+            ["#{namespace}::#{name}", name].each do |path|
+              constant = Shoulda::Matchers::Util.safe_constantize(path)
+
+              if constant
+                return constant
+              end
+            end
+          end
+
+          def actual_value_for_relation_clause(name)
+            reflector.extract_relation_clause_from(
+              reflector.association_relation,
+              name,
+            )
+          end
+
+          def actual_value_for_class_name
+            reflector.associated_class
+          end
+
+          def actual_value_for_strict_loading
+            reflection.strict_loading?
+          end
+
+          def actual_value_for_option(name)
+            option_value = reflection.options[name]
+
+            if option_value.nil?
+              DEFAULT_VALUE_OF_OPTIONS.dig(reflection.macro, name)
+            else
+              option_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_record/association_matchers/optional_matcher.rb

@@ -0,0 +1,71 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class OptionalMatcher
+          attr_reader :missing_option
+
+          def initialize(attribute_name, optional)
+            @attribute_name = attribute_name
+            @optional = optional
+            @submatcher = ActiveModel::AllowValueMatcher.new(nil).
+              for(attribute_name)
+            @missing_option = ''
+          end
+
+          def description
+            "optional: #{optional}"
+          end
+
+          def matches?(subject)
+            if submatcher_passes?(subject)
+              true
+            else
+              @missing_option = build_missing_option
+
+              false
+            end
+          end
+
+          private
+
+          attr_reader :attribute_name, :optional, :submatcher
+
+          def submatcher_passes?(subject)
+            if optional
+              submatcher.matches?(subject)
+            else
+              submatcher.does_not_match?(subject)
+            end
+          end
+
+          def build_missing_option
+            String.new('and for the record ').tap do |missing_option_string|
+              missing_option_string <<
+                if optional
+                  'not to '
+                else
+                  'to '
+                end
+
+              missing_option_string << 'fail validation if '\
+                ":#{attribute_name} is unset; i.e., either the association "\
+                'should have been defined with `optional: '\
+                "#{optional.inspect}`, or there "
+
+              missing_option_string <<
+                if optional
+                  'should not '
+                else
+                  'should '
+                end
+
+              missing_option_string << "be a presence validation on :#{attribute_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end