strict 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e55f68c10dc39769cdc9ae894efe2bbcd1a7ff0ce368b0b9b1d8251162cf1c6e
-  data.tar.gz: a3454e769c6cd9578c3a5fbe4abd6edd6b0518affcd69d89249235df874875f0
+  metadata.gz: 82ad76d91d34f1bd4cc46ea38e4cef3c03c7d7e328f04d3dcc3c555da1eabdb4
+  data.tar.gz: 73f3ca6bc1d03caa42c23f61a3615ccb55285a1dcd962e978be3a87064abf8a3
 SHA512:
-  metadata.gz: 06e647f606756054ece856881aff7de3b7c7fa50301c6b636af116b51ee8f975540b27bd6163391a18b8e8e40db911099e9dc7b1de7eacf38b239267b902287c
-  data.tar.gz: '09130d2f947390b821c9357c3c17a371236f14c864bb42c8165ef651fedb06943e0d6ad6021ae451549cd368e0546e2e15dfd5a12d3ed090c76091cbe178795f'
+  metadata.gz: c442d7d203a993681c89694052856d125ab7c35965fb965ed64250a3eb83476069d844488d64798afc7ddc57b1edafbbbe0d6807b92b3c3a228bf9f3891beecd
+  data.tar.gz: 545e4e331d8ed3e578e72dbb52347bb34a0512fa899ca1da60f3181a2836d06a188658b224feed112a2e21464723833230b750628a1d837346566730375ce803

data/.rubocop.yml

@@ -4,7 +4,7 @@ require:
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.1.2
+  TargetRubyVersion: 3.0.0
 
 Style/CaseEquality:
   Enabled: false

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.0.0

data/Gemfile.lock

@@ -1,22 +1,22 @@
 PATH
   remote: .
   specs:
-    strict (1.0.0)
+    strict (1.2.0)
       zeitwerk (~> 2.6)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    debug (1.6.1)
+    debug (1.6.2)
       irb (>= 1.3.6)
       reline (>= 0.3.1)
     gem-release (2.2.2)
     io-console (0.5.11)
-    irb (1.4.1)
+    irb (1.4.2)
       reline (>= 0.3.0)
     json (2.6.2)
-    minitest (5.16.2)
+    minitest (5.16.3)
     minitest-spec-context (0.0.4)
     parallel (1.22.1)
     parser (3.1.2.1)
@@ -45,7 +45,7 @@ GEM
       rubocop (~> 1.0)
     ruby-progressbar (1.11.0)
     unicode-display_width (2.3.0)
-    zeitwerk (2.6.0)
+    zeitwerk (2.6.1)
 
 PLATFORMS
   arm64-darwin-21
@@ -63,4 +63,4 @@ DEPENDENCIES
   strict!
 
 BUNDLED WITH
-   2.3.22
+   2.3.23

data/README.md

@@ -108,6 +108,71 @@ UpdateEmail.new.call(user_id: "123", email: "456")
 # => Strict::MethodReturnError
 ```
 
+### `Strict::Interface`
+
+```rb
+class Storage
+  extend Strict::Interface
+
+  expose(:write) do
+    key String
+    contents String
+    returns Boolean()
+  end
+
+  expose(:read) do
+    key String
+    returns AnyOf(String, nil)
+  end
+end
+
+module Storages
+  class Memory
+    def initialize
+      @storage = {}
+    end
+
+    def write(key:, contents:)
+      storage[key] = contents
+      true
+    end
+
+    def read(key:)
+      storage[key]
+    end
+
+    private
+
+    attr_reader :storage
+  end
+end
+
+storage = Storage.new(Storages::Memory.new)
+# => #<Storage implementation=#<Storages::Memory>>
+
+storage.write(key: "some/path/to/file.rb", contents: "Hello")
+# => true
+
+storage.write(key: "some/path/to/file.rb", contents: {})
+# => Strict::MethodCallError
+
+storage.read(key: "some/path/to/file.rb")
+# => "Hello"
+
+storage.read(key: "some/path/to/other.rb")
+# => nil
+
+module Storages
+  class Wat
+    def write(key:)
+    end
+  end
+end
+
+storage = Storage.new(Storages::Wat.new)
+# => Strict::ImplementationDoesNotConformError
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/strict/accessor/attributes.rb

@@ -8,7 +8,7 @@ module Strict
         configuration = Strict::Attributes::Dsl.run(&block)
         include Module.new(configuration)
         include Strict::Attributes::Instance
-        extend Strict::Attributes::Configured
+        extend Strict::Attributes::Class
       end
     end
   end

data/lib/strict/accessor/module.rb

@@ -10,13 +10,13 @@ module Strict
         super()
 
         @configuration = configuration
-        const_set(Strict::Attributes::Configured::CONSTANT, configuration)
+        const_set(Strict::Attributes::Class::CONSTANT, configuration)
         configuration.attributes.each do |attribute|
-          module_eval(
-            "def #{attribute.name} = #{attribute.instance_variable}", # def name = @instance_variable
-            __FILE__,
-            __LINE__ - 2
-          )
+          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def #{attribute.name}            # def name
+              #{attribute.instance_variable} #   @instance_variable
+            end                              # end
+          RUBY
 
           module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
             def #{attribute.name}=(value)                                         # def name=(value)
@@ -28,7 +28,7 @@ module Strict
                 raise Strict::AssignmentError.new(                                #     raise Strict::AssignmentError.new(
                   assignable_class: self.class,                                   #       assignable_class: self.class,
                   invalid_attribute: attribute,                                   #       invalid_attribute: attribute,
-                  value:                                                          #       value:
+                  value: value                                                    #       value: value
                 )                                                                 #     )
               end                                                                 #   end
             end                                                                   # end

data/lib/strict/assignment_error.rb

@@ -5,7 +5,7 @@ module Strict
     attr_reader :invalid_attribute, :value
 
     def initialize(assignable_class:, invalid_attribute:, value:)
-      super(message_from(assignable_class:, invalid_attribute:, value:))
+      super(message_from(assignable_class: assignable_class, invalid_attribute: invalid_attribute, value: value))
 
       @invalid_attribute = invalid_attribute
       @value = value

data/lib/strict/attribute.rb

@@ -10,7 +10,12 @@ module Strict
           raise ArgumentError, "Only one of 'default', 'default_value', or 'default_generator' can be provided"
         end
 
-        new(name: name.to_sym, validator:, default_generator: make_default_generator(**defaults), coercer: coerce)
+        new(
+          name: name.to_sym,
+          validator: validator,
+          default_generator: make_default_generator(**defaults),
+          coercer: coerce
+        )
       end
 
       private

data/lib/strict/attributes/{configured.rb → class.rb}

@@ -2,12 +2,16 @@
 
 module Strict
   module Attributes
-    module Configured
+    module Class
       CONSTANT = :STRICT_INTERNAL_ATTRIBUTES_CONFIGURATION__
 
       def strict_attributes
         self::STRICT_INTERNAL_ATTRIBUTES_CONFIGURATION__
       end
+
+      def coercer
+        Coercer.new(self)
+      end
     end
   end
 end

data/lib/strict/attributes/coercer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Strict
+  module Attributes
+    class Coercer
+      attr_reader :attributes_class
+
+      def initialize(attributes_class)
+        @attributes_class = attributes_class
+      end
+
+      def call(value)
+        return value if value.nil? || !value.respond_to?(:to_h)
+
+        coerce(value.to_h)
+      end
+
+      private
+
+      NOT_PROVIDED = ::Object.new.freeze
+
+      def coerce(hash)
+        attributes_class.new(
+          **attributes_class.strict_attributes.each_with_object({}) do |attribute, attributes|
+            value = hash.fetch(attribute.name) { hash.fetch(attribute.name.to_s, NOT_PROVIDED) }
+            attributes[attribute.name] = value unless value.equal?(NOT_PROVIDED)
+          end
+        )
+      end
+    end
+  end
+end

data/lib/strict/attributes/configuration.rb

@@ -12,7 +12,7 @@ module Strict
         attr_reader :attribute_name
 
         def initialize(attribute_name:)
-          super(message_from(attribute_name:))
+          super(message_from(attribute_name: attribute_name))
 
           @attribute_name = attribute_name
         end

data/lib/strict/attributes/dsl.rb

@@ -4,13 +4,14 @@ module Strict
   module Attributes
     class Dsl < BasicObject
       class << self
-        def run(&)
+        def run(&block)
           dsl = new
-          dsl.instance_eval(&)
+          dsl.instance_eval(&block)
           ::Strict::Attributes::Configuration.new(attributes: dsl.__strict_dsl_internal_attributes.values)
         end
       end
 
+      include ::Strict::Dsl::Coercible
       include ::Strict::Dsl::Validatable
 
       attr_reader :__strict_dsl_internal_attributes

data/lib/strict/attributes/instance.rb

@@ -33,9 +33,9 @@ module Strict
 
         raise InitializationError.new(
           initializable_class: self.class,
-          remaining_attributes:,
-          invalid_attributes:,
-          missing_attributes:
+          remaining_attributes: remaining_attributes,
+          invalid_attributes: invalid_attributes,
+          missing_attributes: missing_attributes
         )
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/strict/coercers/array.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Strict
+  module Coercers
+    class Array
+      attr_reader :element_coercer
+
+      def initialize(element_coercer = nil)
+        @element_coercer = element_coercer
+      end
+
+      def call(value)
+        return value if value.nil? || !value.respond_to?(:to_a)
+
+        array = value.to_a
+        return array unless element_coercer
+
+        array.map { |element| element_coercer.call(element) }
+      end
+    end
+  end
+end

data/lib/strict/coercers/hash.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Strict
+  module Coercers
+    class Hash
+      attr_reader :key_coercer, :value_coercer
+
+      def initialize(key_coercer = nil, value_coercer = nil)
+        @key_coercer = key_coercer
+        @value_coercer = value_coercer
+      end
+
+      def call(value)
+        return value if value.nil? || !value.respond_to?(:to_h)
+
+        if key_coercer && value_coercer
+          coerce_keys_and_values(value.to_h)
+        elsif key_coercer
+          coerce_keys(value.to_h)
+        elsif value_coercer
+          coerce_values(value.to_h)
+        else
+          value.to_h
+        end
+      end
+
+      private
+
+      def coerce_keys_and_values(hash) = hash.to_h { |key, value| [key_coercer.call(key), value_coercer.call(value)] }
+      def coerce_keys(hash) = hash.transform_keys { |key| key_coercer.call(key) }
+      def coerce_values(hash) = hash.transform_values { |value| value_coercer.call(value) }
+    end
+  end
+end

data/lib/strict/dsl/coercible.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Strict
+  module Dsl
+    module Coercible
+      # rubocop:disable Naming/MethodName
+
+      def ToArray(with: nil) = ::Strict::Coercers::Array.new(with)
+      def ToHash(with_keys: nil, with_values: nil) = ::Strict::Coercers::Hash.new(with_keys, with_values)
+
+      # rubocop:enable Naming/MethodName
+    end
+  end
+end

data/lib/strict/implementation_does_not_conform_error.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Strict
+  class ImplementationDoesNotConformError < Error
+    attr_reader :interface, :receiver, :missing_methods, :invalid_method_definitions
+
+    def initialize(interface:, receiver:, missing_methods:, invalid_method_definitions:) # rubocop:disable Metrics/MethodLength
+      super(
+        message_from(
+          interface: interface,
+          receiver: receiver,
+          missing_methods: missing_methods,
+          invalid_method_definitions: invalid_method_definitions
+        )
+      )
+
+      @interface = interface
+      @receiver = receiver
+      @missing_methods = missing_methods
+      @invalid_method_definitions = invalid_method_definitions
+    end
+
+    private
+
+    def message_from(interface:, receiver:, missing_methods:, invalid_method_definitions:)
+      details = [
+        missing_methods_message_from(missing_methods),
+        invalid_method_definitions_message_from(invalid_method_definitions)
+      ].compact.join("\n")
+
+      case receiver
+      when ::Class, ::Module
+        "#{receiver}'s implementation of #{interface} does not conform:\n#{details}"
+      else
+        "#{receiver.class}'s implementation of #{interface} does not conform:\n#{details}"
+      end
+    end
+
+    def missing_methods_message_from(missing_methods)
+      return nil unless missing_methods
+
+      details = missing_methods.map do |method_name|
+        "    - #{method_name}"
+      end.join("\n")
+
+      "  Some methods exposed in the interface were not defined in the implementation:\n#{details}"
+    end
+
+    def invalid_method_definitions_message_from(invalid_method_definitions)
+      return nil if invalid_method_definitions.empty?
+
+      methods_details = invalid_method_definitions.map do |name, invalid_method_definition|
+        method_details = [
+          missing_parameters_message_from(invalid_method_definition.fetch(:missing_parameters)),
+          additional_parameters_message_from(invalid_method_definition.fetch(:additional_parameters)),
+          non_keyword_parameters_message_from(invalid_method_definition.fetch(:non_keyword_parameters))
+        ].compact.join("\n")
+
+        "    #{name}:\n#{method_details}"
+      end.join("\n")
+
+      "  Some methods defined in the implementation did not conform to their interface:\n#{methods_details}"
+    end
+
+    def missing_parameters_message_from(missing_parameters)
+      return nil unless missing_parameters.any?
+
+      details = missing_parameters.map do |parameter_name|
+        "        - #{parameter_name}"
+      end.join("\n")
+
+      "      Some parameters were expected, but were not in the parameter list:\n#{details}"
+    end
+
+    def additional_parameters_message_from(additional_parameters)
+      return nil unless additional_parameters.any?
+
+      details = additional_parameters.map do |parameter_name|
+        "        - #{parameter_name}"
+      end.join("\n")
+
+      "      Some parameters were not expected, but were in the parameter list:\n#{details}"
+    end
+
+    def non_keyword_parameters_message_from(non_keyword_parameters)
+      return nil unless non_keyword_parameters.any?
+
+      details = non_keyword_parameters.map do |parameter_name|
+        "        - #{parameter_name}"
+      end.join("\n")
+
+      "      Some parameters were not keywords, but only keywords are supported:\n#{details}"
+    end
+  end
+end

data/lib/strict/initialization_error.rb

@@ -4,8 +4,15 @@ module Strict
   class InitializationError < Error
     attr_reader :remaining_attributes, :invalid_attributes, :missing_attributes
 
-    def initialize(initializable_class:, remaining_attributes:, invalid_attributes:, missing_attributes:)
-      super(message_from(initializable_class:, remaining_attributes:, invalid_attributes:, missing_attributes:))
+    def initialize(initializable_class:, remaining_attributes:, invalid_attributes:, missing_attributes:) # rubocop:disable Metrics/MethodLength
+      super(
+        message_from(
+          initializable_class: initializable_class,
+          remaining_attributes: remaining_attributes,
+          invalid_attributes: invalid_attributes,
+          missing_attributes: missing_attributes
+        )
+      )
 
       @remaining_attributes = remaining_attributes
       @invalid_attributes = invalid_attributes

data/lib/strict/interface.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Strict
+  module Interface
+    def self.extended(mod)
+      mod.extend(Strict::Method)
+      mod.include(Interfaces::Instance)
+    end
+
+    def expose(method_name, &block)
+      sig = sig(&block)
+      parameter_list = sig.parameters.map { |parameter| "#{parameter.name}:" }.join(", ")
+      argument_list = sig.parameters.map { |parameter| "#{parameter.name}: #{parameter.name}" }.join(", ")
+
+      module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def #{method_name}(#{parameter_list}, &block)              # def method_name(one:, two:, three:, &block)
+          implementation.#{method_name}(#{argument_list}, &block)  #   implementation.method_name(one: one, two: two, three: three, &block)
+        end                                                        # end
+      RUBY
+    end
+  end
+end

data/lib/strict/interfaces/instance.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Strict
+  module Interfaces
+    module Instance
+      attr_reader :implementation
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def initialize(implementation)
+        missing_methods = nil
+        invalid_method_definitions = Hash.new do |h, k|
+          h[k] = { additional_parameters: [], missing_parameters: [], non_keyword_parameters: [] }
+        end
+
+        self.class.strict_instance_methods.each do |method_name, strict_method|
+          unless implementation.respond_to?(method_name)
+            missing_methods ||= []
+            missing_methods << method_name
+            next
+          end
+
+          expected_parameters = Set.new(strict_method.parameters.map(&:name))
+          defined_parameters = Set.new
+
+          implementation.method(method_name).parameters.each do |kind, parameter_name|
+            next if kind == :block
+
+            if expected_parameters.include?(parameter_name)
+              defined_parameters.add(parameter_name)
+              invalid_method_definitions[method_name][:non_keyword_parameters] << parameter_name if kind != :keyreq
+            else
+              invalid_method_definitions[method_name][:additional_parameters] << parameter_name
+            end
+          end
+
+          missing_parameters = expected_parameters - defined_parameters
+          invalid_method_definitions[method_name][:missing_parameters] = missing_parameters if missing_parameters.any?
+        end
+
+        if missing_methods || !invalid_method_definitions.empty?
+          raise Strict::ImplementationDoesNotConformError.new(
+            interface: self.class,
+            receiver: implementation,
+            missing_methods: missing_methods,
+            invalid_method_definitions: invalid_method_definitions
+          )
+        end
+
+        @implementation = implementation
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/strict/method.rb

@@ -8,9 +8,27 @@ module Strict
       mod.singleton_class.extend(self)
     end
 
-    def sig(&)
+    def sig(&block)
       instance = singleton_class? ? self : singleton_class
-      instance.instance_variable_set(:@__strict_method_internal_last_sig_configuration, Methods::Dsl.run(&))
+      instance.instance_variable_set(:@__strict_method_internal_last_sig_configuration, Methods::Dsl.run(&block))
+    end
+
+    def strict_class_methods
+      instance = singleton_class? ? self : singleton_class
+      if instance.instance_variable_defined?(:@__strict_method_internal_class_methods)
+        instance.instance_variable_get(:@__strict_method_internal_class_methods)
+      else
+        instance.instance_variable_set(:@__strict_method_internal_class_methods, {})
+      end
+    end
+
+    def strict_instance_methods
+      instance = singleton_class? ? self : singleton_class
+      if instance.instance_variable_defined?(:@__strict_method_internal_instance_methods)
+        instance.instance_variable_get(:@__strict_method_internal_instance_methods)
+      else
+        instance.instance_variable_set(:@__strict_method_internal_instance_methods, {})
+      end
     end
 
     # rubocop:disable Metrics/MethodLength
@@ -28,6 +46,7 @@ module Strict
         instance: false
       )
       verifiable_method.verify_definition!
+      strict_class_methods[method_name] = verifiable_method
       singleton_class.prepend(Methods::Module.new(verifiable_method))
     end
 
@@ -45,6 +64,7 @@ module Strict
         instance: true
       )
       verifiable_method.verify_definition!
+      strict_instance_methods[method_name] = verifiable_method
       prepend(Methods::Module.new(verifiable_method))
     end
     # rubocop:enable Metrics/MethodLength

data/lib/strict/method_call_error.rb

@@ -4,9 +4,15 @@ module Strict
   class MethodCallError < Error
     attr_reader :verifiable_method, :remaining_args, :remaining_kwargs, :invalid_parameters, :missing_parameters
 
-    def initialize(verifiable_method:, remaining_args:, remaining_kwargs:, invalid_parameters:, missing_parameters:)
+    def initialize(verifiable_method:, remaining_args:, remaining_kwargs:, invalid_parameters:, missing_parameters:) # rubocop:disable Metrics/MethodLength
       super(
-        message_from(verifiable_method:, remaining_args:, remaining_kwargs:, invalid_parameters:, missing_parameters:)
+        message_from(
+          verifiable_method: verifiable_method,
+          remaining_args: remaining_args,
+          remaining_kwargs: remaining_kwargs,
+          invalid_parameters: invalid_parameters,
+          missing_parameters: missing_parameters
+        )
       )
 
       @verifiable_method = verifiable_method

data/lib/strict/method_definition_error.rb

@@ -5,7 +5,13 @@ module Strict
     attr_reader :verifiable_method, :missing_parameters, :additional_parameters
 
     def initialize(verifiable_method:, missing_parameters:, additional_parameters:)
-      super(message_from(verifiable_method:, missing_parameters:, additional_parameters:))
+      super(
+        message_from(
+          verifiable_method: verifiable_method,
+          missing_parameters: missing_parameters,
+          additional_parameters: additional_parameters
+        )
+      )
 
       @verifiable_method = verifiable_method
       @missing_parameters = missing_parameters
@@ -30,7 +36,7 @@ module Strict
         "    - #{parameter_name}"
       end.join("\n")
 
-      "  Some parameters were in the `sig`, but were not in the parameter list:\n#{details}"
+      "  Some parameters were in the sig, but were not in the parameter list:\n#{details}"
     end
 
     def additional_parameters_message_from(additional_parameters)
@@ -40,7 +46,7 @@ module Strict
         "    - #{parameter_name}"
       end.join("\n")
 
-      "  Some parameters were not in the `sig`, but were in the parameter list:\n#{details}"
+      "  Some parameters were not in the sig, but were in the parameter list:\n#{details}"
     end
   end
 end

data/lib/strict/method_return_error.rb

@@ -5,7 +5,7 @@ module Strict
     attr_reader :verifiable_method, :value
 
     def initialize(verifiable_method:, value:)
-      super(message_from(verifiable_method:, value:))
+      super(message_from(verifiable_method: verifiable_method, value: value))
 
       @verifiable_method = verifiable_method
       @value = value

data/lib/strict/methods/dsl.rb

@@ -4,9 +4,9 @@ module Strict
   module Methods
     class Dsl < BasicObject
       class << self
-        def run(&)
+        def run(&block)
           dsl = new
-          dsl.instance_eval(&)
+          dsl.instance_eval(&block)
           ::Strict::Methods::Configuration.new(
             parameters: dsl.__strict_dsl_internal_parameters.values,
             returns: dsl.__strict_dsl_internal_returns
@@ -14,6 +14,7 @@ module Strict
         end
       end
 
+      include ::Strict::Dsl::Coercible
       include ::Strict::Dsl::Validatable
 
       attr_reader :__strict_dsl_internal_parameters, :__strict_dsl_internal_returns

data/lib/strict/methods/verifiable_method.rb

@@ -11,7 +11,7 @@ module Strict
         attr_reader :parameter_name
 
         def initialize(parameter_name:)
-          super(message_from(parameter_name:))
+          super(message_from(parameter_name: parameter_name))
 
           @parameter_name = parameter_name
         end
@@ -47,7 +47,11 @@ module Strict
 
         missing_parameters = expected_parameters - defined_parameters
         additional_parameters = defined_parameters - expected_parameters
-        raise Strict::MethodDefinitionError.new(verifiable_method: self, missing_parameters:, additional_parameters:)
+        raise Strict::MethodDefinitionError.new(
+          verifiable_method: self,
+          missing_parameters: missing_parameters,
+          additional_parameters: additional_parameters
+        )
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
@@ -113,8 +117,8 @@ module Strict
             verifiable_method: self,
             remaining_args: args,
             remaining_kwargs: kwargs,
-            invalid_parameters:,
-            missing_parameters:
+            invalid_parameters: invalid_parameters,
+            missing_parameters: missing_parameters
           )
         end
       end
@@ -124,7 +128,7 @@ module Strict
         value = returns.coerce(value)
         return if returns.valid?(value)
 
-        raise Strict::MethodReturnError.new(verifiable_method: self, value:)
+        raise Strict::MethodReturnError.new(verifiable_method: self, value: value)
       end
 
       private

data/lib/strict/parameter.rb

@@ -10,7 +10,12 @@ module Strict
           raise ArgumentError, "Only one of 'default', 'default_value', or 'default_generator' can be provided"
         end
 
-        new(name: name.to_sym, validator:, default_generator: make_default_generator(**defaults), coercer: coerce)
+        new(
+          name: name.to_sym,
+          validator: validator,
+          default_generator: make_default_generator(**defaults),
+          coercer: coerce
+        )
       end
 
       private

data/lib/strict/reader/attributes.rb

@@ -8,7 +8,7 @@ module Strict
         configuration = Strict::Attributes::Dsl.run(&block)
         include Module.new(configuration)
         include Strict::Attributes::Instance
-        extend Strict::Attributes::Configured
+        extend Strict::Attributes::Class
       end
     end
   end

data/lib/strict/reader/module.rb

@@ -9,7 +9,7 @@ module Strict
         super()
 
         @configuration = configuration
-        const_set(Strict::Attributes::Configured::CONSTANT, configuration)
+        const_set(Strict::Attributes::Class::CONSTANT, configuration)
         configuration.attributes.each do |attribute|
           module_eval(
             "def #{attribute.name} = #{attribute.instance_variable}", # def name = @instance_variable

data/lib/strict/return.rb

@@ -4,7 +4,7 @@ module Strict
   class Return
     class << self
       def make(validator = Validators::Anything.instance, coerce: false)
-        new(validator:, coercer: coerce)
+        new(validator: validator, coercer: coerce)
       end
     end
 

data/lib/strict/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Strict
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/strict.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Strictly define a contract for your objects and methods"
   spec.homepage = "https://github.com/kylekthompson/strict"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.2"
+  spec.required_ruby_version = ">= 3.0.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strict
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Kyle Thompson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-12 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -144,6 +144,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rubocop.yml"
+- ".tool-versions"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -156,13 +157,20 @@ files:
 - lib/strict/accessor/module.rb
 - lib/strict/assignment_error.rb
 - lib/strict/attribute.rb
+- lib/strict/attributes/class.rb
+- lib/strict/attributes/coercer.rb
 - lib/strict/attributes/configuration.rb
-- lib/strict/attributes/configured.rb
 - lib/strict/attributes/dsl.rb
 - lib/strict/attributes/instance.rb
+- lib/strict/coercers/array.rb
+- lib/strict/coercers/hash.rb
+- lib/strict/dsl/coercible.rb
 - lib/strict/dsl/validatable.rb
 - lib/strict/error.rb
+- lib/strict/implementation_does_not_conform_error.rb
 - lib/strict/initialization_error.rb
+- lib/strict/interface.rb
+- lib/strict/interfaces/instance.rb
 - lib/strict/method.rb
 - lib/strict/method_call_error.rb
 - lib/strict/method_definition_error.rb
@@ -204,14 +212,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.2
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Strictly define a contract for your objects and methods