ultra-fast-box 0.0.1

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

@@ -0,0 +1,37 @@
+require 'shoulda/matchers/active_record/association_matcher'
+require 'shoulda/matchers/active_record/association_matchers'
+require 'shoulda/matchers/active_record/association_matchers/counter_cache_matcher'
+require 'shoulda/matchers/active_record/association_matchers/inverse_of_matcher'
+require 'shoulda/matchers/active_record/association_matchers/join_table_matcher'
+require 'shoulda/matchers/active_record/association_matchers/order_matcher'
+require 'shoulda/matchers/active_record/association_matchers/through_matcher'
+require 'shoulda/matchers/active_record/association_matchers/dependent_matcher'
+require 'shoulda/matchers/active_record/association_matchers/required_matcher'
+require 'shoulda/matchers/active_record/association_matchers/optional_matcher'
+require 'shoulda/matchers/active_record/association_matchers/source_matcher'
+require 'shoulda/matchers/active_record/association_matchers/model_reflector'
+require 'shoulda/matchers/active_record/association_matchers/model_reflection'
+require 'shoulda/matchers/active_record/association_matchers/option_verifier'
+require 'shoulda/matchers/active_record/have_db_column_matcher'
+require 'shoulda/matchers/active_record/have_db_index_matcher'
+require 'shoulda/matchers/active_record/have_implicit_order_column'
+require 'shoulda/matchers/active_record/have_readonly_attribute_matcher'
+require 'shoulda/matchers/active_record/have_rich_text_matcher'
+require 'shoulda/matchers/active_record/have_secure_token_matcher'
+require 'shoulda/matchers/active_record/serialize_matcher'
+require 'shoulda/matchers/active_record/accept_nested_attributes_for_matcher'
+require 'shoulda/matchers/active_record/define_enum_for_matcher'
+require 'shoulda/matchers/active_record/uniqueness'
+require 'shoulda/matchers/active_record/validate_uniqueness_of_matcher'
+require 'shoulda/matchers/active_record/have_attached_matcher'
+require 'shoulda/matchers/active_record/normalize_matcher'
+require 'shoulda/matchers/active_record/encrypt_matcher'
+
+module Shoulda
+  module Matchers
+    # This module provides matchers that are used to test behavior within
+    # ActiveRecord classes.
+    module ActiveRecord
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/configuration.rb

@@ -0,0 +1,31 @@
+module Shoulda
+  module Matchers
+    # @private
+    def self.configure
+      yield configuration
+    end
+
+    # @private
+    def self.integrations
+      configuration.integrations
+    end
+
+    # @private
+    def self.configuration
+      @_configuration ||= Configuration.new
+    end
+
+    # @private
+    class Configuration
+      attr_reader :integrations
+
+      def initialize
+        @integrations = nil
+      end
+
+      def integrate(&block)
+        @integrations = Integrations::Configuration.apply(&block)
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/double.rb

@@ -0,0 +1,103 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      class Double
+        attr_reader :calls
+
+        def initialize(world, klass, method_name, implementation)
+          @world = world
+          @klass = klass
+          @method_name = method_name
+          @implementation = implementation
+          @activated = false
+          @calls = []
+
+          if world.doubles_activated?
+            activate
+          end
+        end
+
+        def activated?
+          @activated
+        end
+
+        def to_return(value = nil, &block)
+          if block
+            implementation.returns(&block)
+          else
+            implementation.returns(value)
+          end
+        end
+
+        def activate
+          unless @activated
+            store_original_method
+            replace_method_with_double
+            @activated = true
+          end
+        end
+
+        def deactivate
+          if @activated
+            restore_original_method
+            @activated = false
+          end
+        end
+
+        def record_call(call)
+          calls << call
+        end
+
+        def call_original_method(call)
+          unbound_method = world.original_method_for(klass, call.method_name)
+
+          if unbound_method
+            unbound_method.bind(call.object).call(*call.args, &call.block)
+          end
+        end
+
+        protected
+
+        attr_reader :world, :klass, :method_name, :implementation,
+          :original_method
+
+        def store_original_method
+          world.store_original_method_for(klass, method_name)
+        end
+
+        def replace_method_with_double
+          double = self
+          implementation = @implementation
+          _method_name = method_name
+
+          if klass.instance_methods(false).include?(method_name)
+            klass.__send__(:remove_method, method_name)
+          end
+
+          klass.__send__(:define_method, method_name) do |*args, &block|
+            call = MethodCall.new(
+              double:,
+              object: self,
+              method_name: _method_name,
+              args:,
+              block:,
+              caller:,
+            )
+            implementation.call(call)
+          end
+        end
+
+        def restore_original_method
+          original_method = world.original_method_for(klass, method_name)
+
+          klass.__send__(:remove_method, method_name)
+
+          klass.__send__(:define_method, method_name) do |*args, &block|
+            original_method.bind(self).call(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/double_collection.rb

@@ -0,0 +1,60 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      class DoubleCollection
+        def initialize(world, klass)
+          @world = world
+          @klass = klass
+          @doubles_by_method_name = {}
+        end
+
+        def register_stub(method_name)
+          register_double(method_name, :stub)
+        end
+
+        def register_proxy(method_name)
+          register_double(method_name, :proxy)
+        end
+
+        def activate
+          doubles_by_method_name.each_value(&:activate)
+        end
+
+        def deactivate
+          doubles_by_method_name.each_value(&:deactivate)
+        end
+
+        def calls_by_method_name
+          doubles_by_method_name.inject({}) do |hash, (method_name, double)|
+            hash.merge! method_name => double.calls.map(&:args)
+          end
+        end
+
+        def calls_to(method_name)
+          double = doubles_by_method_name[method_name]
+
+          if double
+            double.calls
+          else
+            []
+          end
+        end
+
+        protected
+
+        attr_reader :world, :klass, :doubles_by_method_name
+
+        def register_double(method_name, implementation_type)
+          doubles_by_method_name.fetch(method_name) do
+            implementation =
+              DoubleImplementationRegistry.find(implementation_type)
+            double = Double.new(world, klass, method_name, implementation)
+            doubles_by_method_name[method_name] = double
+            double
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/double_implementation_registry.rb

@@ -0,0 +1,31 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      module DoubleImplementationRegistry
+        class << self
+          def find(type)
+            find_class!(type).create
+          end
+
+          def register(klass, type)
+            registry[type] = klass
+          end
+
+          private
+
+          def find_class!(type)
+            registry.fetch(type) do
+              raise ArgumentError, 'No double implementation class found for'\
+                " '#{type}'"
+            end
+          end
+
+          def registry
+            @_registry ||= {}
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/method_call.rb

@@ -0,0 +1,44 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      class MethodCall
+        attr_accessor :return_value
+        attr_reader :method_name, :args, :caller, :block, :object, :double
+
+        def initialize(args)
+          @method_name = args.fetch(:method_name)
+          @args = args.fetch(:args)
+          @caller = args.fetch(:caller)
+          @block = args[:block]
+          @double = args[:double]
+          @object = args[:object]
+          @return_value = nil
+        end
+
+        def with_return_value(return_value)
+          dup.tap do |call|
+            call.return_value = return_value
+          end
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            method_name == other.method_name &&
+            args == other.args &&
+            block == other.block &&
+            double == other.double &&
+            object == other.object
+        end
+
+        def to_hash
+          { method_name:, args: }
+        end
+
+        def inspect
+          "#<#{self.class.name} #{to_hash.inspect}>"
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/object_double.rb

@@ -0,0 +1,43 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      class ObjectDouble < BasicObject
+        attr_reader :calls
+
+        def initialize
+          @calls = []
+          @calls_by_method_name = {}
+        end
+
+        def calls_to(method_name)
+          @calls_by_method_name[method_name] || []
+        end
+
+        def respond_to?(_name, _include_private = nil)
+          true
+        end
+
+        def respond_to_missing?(_name, _include_all)
+          true
+        end
+
+        def method_missing(method_name, *args, &block)
+          call = MethodCall.new(
+            method_name:,
+            args:,
+            block:,
+            caller: ::Kernel.caller,
+          )
+          calls << call
+          (calls_by_method_name[method_name] ||= []) << call
+          nil
+        end
+
+        protected
+
+        attr_reader :calls_by_method_name
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/proxy_implementation.rb

@@ -0,0 +1,32 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      class ProxyImplementation
+        extend Forwardable
+
+        DoubleImplementationRegistry.register(self, :proxy)
+
+        def_delegators :stub_implementation, :returns
+
+        def self.create
+          new(StubImplementation.new)
+        end
+
+        def initialize(stub_implementation)
+          @stub_implementation = stub_implementation
+        end
+
+        def call(call)
+          return_value = call.double.call_original_method(call)
+          stub_implementation.call(call.with_return_value(return_value))
+          return_value
+        end
+
+        protected
+
+        attr_reader :stub_implementation
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/stub_implementation.rb

@@ -0,0 +1,31 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      class StubImplementation
+        DoubleImplementationRegistry.register(self, :stub)
+
+        def self.create
+          new
+        end
+
+        def initialize
+          @implementation = proc { nil }
+        end
+
+        def returns(value = nil, &block)
+          @implementation = block || proc { value }
+        end
+
+        def call(call)
+          call.double.record_call(call)
+          implementation.call(call)
+        end
+
+        protected
+
+        attr_reader :implementation
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak/world.rb

@@ -0,0 +1,63 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      # @private
+      class World
+        def initialize
+          @doubles_activated = false
+        end
+
+        def double_collection_for(klass)
+          double_collections_by_class[klass] ||=
+            DoubleCollection.new(self, klass)
+        end
+
+        def store_original_method_for(klass, method_name)
+          original_methods_for_class(klass)[method_name] ||=
+            klass.instance_method(method_name)
+        end
+
+        def original_method_for(klass, method_name)
+          if original_methods_by_class.key?(klass)
+            original_methods_by_class[klass][method_name]
+          end
+        end
+
+        def with_doubles_activated
+          @doubles_activated = true
+          activate
+          yield
+        ensure
+          @doubles_activated = false
+          deactivate
+        end
+
+        def doubles_activated?
+          @doubles_activated
+        end
+
+        private
+
+        def activate
+          double_collections_by_class.each_value(&:activate)
+        end
+
+        def deactivate
+          double_collections_by_class.each_value(&:deactivate)
+        end
+
+        def double_collections_by_class
+          @_double_collections_by_class ||= {}
+        end
+
+        def original_methods_by_class
+          @_original_methods_by_class ||= {}
+        end
+
+        def original_methods_for_class(klass)
+          original_methods_by_class[klass] ||= {}
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/doublespeak.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+
+module Shoulda
+  module Matchers
+    # @private
+    module Doublespeak
+      class << self
+        extend Forwardable
+
+        def_delegators :world, :double_collection_for,
+          :with_doubles_activated
+
+        def world
+          @_world ||= World.new
+        end
+
+        def debugging_enabled?
+          ENV['DEBUG_DOUBLESPEAK'] == '1'
+        end
+
+        def debug(&block)
+          if debugging_enabled?
+            puts block.call # rubocop:disable Rails/Output
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'shoulda/matchers/doublespeak/double'
+require 'shoulda/matchers/doublespeak/double_collection'
+require 'shoulda/matchers/doublespeak/double_implementation_registry'
+require 'shoulda/matchers/doublespeak/method_call'
+require 'shoulda/matchers/doublespeak/object_double'
+require 'shoulda/matchers/doublespeak/proxy_implementation'
+require 'shoulda/matchers/doublespeak/stub_implementation'
+require 'shoulda/matchers/doublespeak/world'

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/error.rb

@@ -0,0 +1,29 @@
+module Shoulda
+  module Matchers
+    # @private
+    class Error < StandardError
+      def self.create(attributes)
+        allocate.tap do |error|
+          attributes.each do |name, value|
+            error.__send__("#{name}=", value)
+          end
+
+          error.__send__(:initialize)
+        end
+      end
+
+      def initialize(*args)
+        super
+        @message = message
+      end
+
+      def message
+        ''
+      end
+
+      def inspect
+        %(#<#{self.class}: #{message}>)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Shoulda
+  module Matchers
+    module Independent
+      class DelegateMethodMatcher
+        # @private
+        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
+          end
+        end
+      end
+    end
+  end
+end