strict 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e55f68c10dc39769cdc9ae894efe2bbcd1a7ff0ce368b0b9b1d8251162cf1c6e
-  data.tar.gz: a3454e769c6cd9578c3a5fbe4abd6edd6b0518affcd69d89249235df874875f0
+  metadata.gz: 2bf58678470f8cc840c19af0f64ce47ea55abe7124779d1b37ebe10707708d41
+  data.tar.gz: 02fb60b1183ab1d5eb90c8438a2271512db588438e75f1f89958e67325788360
 SHA512:
-  metadata.gz: 06e647f606756054ece856881aff7de3b7c7fa50301c6b636af116b51ee8f975540b27bd6163391a18b8e8e40db911099e9dc7b1de7eacf38b239267b902287c
-  data.tar.gz: '09130d2f947390b821c9357c3c17a371236f14c864bb42c8165ef651fedb06943e0d6ad6021ae451549cd368e0546e2e15dfd5a12d3ed090c76091cbe178795f'
+  metadata.gz: e333d0836e79b87dfe89fbdc88c915506609a815b1bfce94b4432f40cdf87696c94da52294d3410d11faa48de6c2197194f8be1216cc50ccce2fc9871ab543fc
+  data.tar.gz: 14c429b220b1a1c890f164daf50dbda22b86d85659abd1c4a8980abd90785d6c52efc7840af85a75740f2dd928c45861d1244061eb703f5e1461b4cabbe8c2f9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    strict (1.0.0)
+    strict (1.1.0)
       zeitwerk (~> 2.6)
 
 GEM
@@ -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

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,7 +10,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/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/dsl.rb

@@ -11,6 +11,7 @@ module Strict
         end
       end
 
+      include ::Strict::Dsl::Coercible
       include ::Strict::Dsl::Validatable
 
       attr_reader :__strict_dsl_internal_attributes

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,88 @@
+# 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:)
+      super(message_from(interface:, receiver:, missing_methods:, 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/interface.rb

@@ -0,0 +1,21 @@
+# 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, &)
+      sig = sig(&)
+      parameter_list = sig.parameters.map { |parameter| "#{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}(#{parameter_list}, &block) #   implementation.method_name(one:, two:, 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:,
+            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

@@ -13,6 +13,24 @@ module Strict
       instance.instance_variable_set(:@__strict_method_internal_last_sig_configuration, Methods::Dsl.run(&))
     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
     def singleton_method_added(method_name)
       super
@@ -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_definition_error.rb

@@ -30,7 +30,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 +40,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/methods/dsl.rb

@@ -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/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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strict
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.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
@@ -156,13 +156,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