strict 0.0.0 → 1.1.0

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/dsl/validatable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Strict
+  module Dsl
+    module Validatable
+      # rubocop:disable Naming/MethodName
+
+      def AllOf(*subvalidators) = ::Strict::Validators::AllOf.new(*subvalidators)
+      def AnyOf(*subvalidators) = ::Strict::Validators::AnyOf.new(*subvalidators)
+      def Anything = ::Strict::Validators::Anything.instance
+      def ArrayOf(element_validator) = ::Strict::Validators::ArrayOf.new(element_validator)
+      def Boolean = ::Strict::Validators::Boolean.instance
+
+      def HashOf(key_validator_to_value_validator)
+        if key_validator_to_value_validator.size != 1
+          raise ArgumentError, "HashOf's usage is: HashOf(KeyValidator => ValueValidator)"
+        end
+
+        key_validator, value_validator = key_validator_to_value_validator.first
+        ::Strict::Validators::HashOf.new(key_validator, value_validator)
+      end
+
+      def RangeOf(element_validator) = ::Strict::Validators::RangeOf.new(element_validator)
+
+      # 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/initialization_error.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+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:))
+
+      @remaining_attributes = remaining_attributes
+      @invalid_attributes = invalid_attributes
+      @missing_attributes = missing_attributes
+    end
+
+    private
+
+    def message_from(initializable_class:, remaining_attributes:, invalid_attributes:, missing_attributes:)
+      details = [
+        invalid_attributes_message_from(invalid_attributes),
+        missing_attributes_message_from(missing_attributes),
+        remaining_attributes_message_from(remaining_attributes)
+      ].compact.join("\n")
+
+      "Initialization of #{initializable_class} failed because:\n#{details}"
+    end
+
+    def invalid_attributes_message_from(invalid_attributes)
+      return nil unless invalid_attributes
+
+      details = invalid_attributes.map do |attribute, value|
+        "    - #{attribute.name}: got #{value.inspect}, expected #{attribute.validator.inspect}"
+      end.join("\n")
+
+      "  Some attributes were invalid:\n#{details}"
+    end
+
+    def missing_attributes_message_from(missing_attributes)
+      return nil unless missing_attributes
+
+      details = missing_attributes.map do |attribute_name|
+        "    - #{attribute_name}"
+      end.join("\n")
+
+      "  Some attributes were missing:\n#{details}"
+    end
+
+    def remaining_attributes_message_from(remaining_attributes)
+      return nil if remaining_attributes.none?
+
+      details = remaining_attributes.map do |attribute_name|
+        "    - #{attribute_name}"
+      end.join("\n")
+
+      "  Some attributes were provided, but not defined:\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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Strict
+  module Method
+    def self.extended(mod)
+      return if mod.singleton_class?
+
+      mod.singleton_class.extend(self)
+    end
+
+    def sig(&)
+      instance = singleton_class? ? self : singleton_class
+      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
+
+      sig = singleton_class.instance_variable_get(:@__strict_method_internal_last_sig_configuration)
+      singleton_class.instance_variable_set(:@__strict_method_internal_last_sig_configuration, nil)
+      return unless sig
+
+      verifiable_method = Methods::VerifiableMethod.new(
+        method: singleton_class.instance_method(method_name),
+        parameters: sig.parameters,
+        returns: sig.returns,
+        instance: false
+      )
+      verifiable_method.verify_definition!
+      strict_class_methods[method_name] = verifiable_method
+      singleton_class.prepend(Methods::Module.new(verifiable_method))
+    end
+
+    def method_added(method_name)
+      super
+
+      sig = singleton_class.instance_variable_get(:@__strict_method_internal_last_sig_configuration)
+      singleton_class.instance_variable_set(:@__strict_method_internal_last_sig_configuration, nil)
+      return unless sig
+
+      verifiable_method = Methods::VerifiableMethod.new(
+        method: instance_method(method_name),
+        parameters: sig.parameters,
+        returns: sig.returns,
+        instance: true
+      )
+      verifiable_method.verify_definition!
+      strict_instance_methods[method_name] = verifiable_method
+      prepend(Methods::Module.new(verifiable_method))
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/strict/method_call_error.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+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:)
+      super(
+        message_from(verifiable_method:, remaining_args:, remaining_kwargs:, invalid_parameters:, missing_parameters:)
+      )
+
+      @verifiable_method = verifiable_method
+      @remaining_args = remaining_args
+      @remaining_kwargs = remaining_kwargs
+      @invalid_parameters = invalid_parameters
+      @missing_parameters = missing_parameters
+    end
+
+    private
+
+    def message_from(verifiable_method:, remaining_args:, remaining_kwargs:, invalid_parameters:, missing_parameters:)
+      details = [
+        invalid_parameters_message_from(invalid_parameters),
+        missing_parameters_message_from(missing_parameters),
+        remaining_args_message_from(remaining_args),
+        remaining_kwargs_message_from(remaining_kwargs)
+      ].compact.join("\n")
+
+      "Calling #{verifiable_method} failed because:\n#{details}"
+    end
+
+    def invalid_parameters_message_from(invalid_parameters)
+      return nil unless invalid_parameters
+
+      details = invalid_parameters.map do |parameter, value|
+        "    - #{parameter.name}: got #{value.inspect}, expected #{parameter.validator.inspect}"
+      end.join("\n")
+
+      "  Some arguments were invalid:\n#{details}"
+    end
+
+    def missing_parameters_message_from(missing_parameters)
+      return nil unless missing_parameters
+
+      details = missing_parameters.map do |parameter_name|
+        "    - #{parameter_name}"
+      end.join("\n")
+
+      "  Some arguments were missing:\n#{details}"
+    end
+
+    def remaining_args_message_from(remaining_args)
+      return nil if remaining_args.none?
+
+      details = remaining_args.map do |arg|
+        "    - #{arg.inspect}"
+      end.join("\n")
+
+      "  Additional positional arguments were provided, but not defined:\n#{details}"
+    end
+
+    def remaining_kwargs_message_from(remaining_kwargs)
+      return nil if remaining_kwargs.none?
+
+      details = remaining_kwargs.map do |key, value|
+        "    - #{key}: #{value.inspect}"
+      end.join("\n")
+
+      "  Additional keyword arguments were provided, but not defined:\n#{details}"
+    end
+  end
+end

data/lib/strict/method_definition_error.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Strict
+  class MethodDefinitionError < Error
+    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:))
+
+      @verifiable_method = verifiable_method
+      @missing_parameters = missing_parameters
+      @additional_parameters = additional_parameters
+    end
+
+    private
+
+    def message_from(verifiable_method:, missing_parameters:, additional_parameters:)
+      details = [
+        missing_parameters_message_from(missing_parameters),
+        additional_parameters_message_from(additional_parameters)
+      ].compact.join("\n")
+
+      "Defining #{verifiable_method} failed because:\n#{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 in the sig, 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 in the sig, but were in the parameter list:\n#{details}"
+    end
+  end
+end

data/lib/strict/method_return_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Strict
+  class MethodReturnError < Error
+    attr_reader :verifiable_method, :value
+
+    def initialize(verifiable_method:, value:)
+      super(message_from(verifiable_method:, value:))
+
+      @verifiable_method = verifiable_method
+      @value = value
+    end
+
+    private
+
+    def message_from(verifiable_method:, value:)
+      details = invalid_returns_message_from(verifiable_method, value)
+      "#{verifiable_method}'s return value was invalid because:\n#{details}"
+    end
+
+    def invalid_returns_message_from(verifiable_method, value)
+      "  - got #{value.inspect}, expected #{verifiable_method.returns.validator.inspect}"
+    end
+  end
+end

data/lib/strict/methods/configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Strict
+  module Methods
+    class Configuration
+      attr_reader :parameters, :returns
+
+      def initialize(parameters:, returns:)
+        @parameters = parameters
+        @returns = returns
+      end
+    end
+  end
+end

data/lib/strict/methods/dsl.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Strict
+  module Methods
+    class Dsl < BasicObject
+      class << self
+        def run(&)
+          dsl = new
+          dsl.instance_eval(&)
+          ::Strict::Methods::Configuration.new(
+            parameters: dsl.__strict_dsl_internal_parameters.values,
+            returns: dsl.__strict_dsl_internal_returns
+          )
+        end
+      end
+
+      include ::Strict::Dsl::Coercible
+      include ::Strict::Dsl::Validatable
+
+      attr_reader :__strict_dsl_internal_parameters, :__strict_dsl_internal_returns
+
+      def initialize
+        @__strict_dsl_internal_parameters = {}
+        @__strict_dsl_internal_returns = ::Strict::Return.make
+      end
+
+      def returns(*args, **kwargs)
+        self.__strict_dsl_internal_returns = ::Strict::Return.make(*args, **kwargs)
+        nil
+      end
+
+      def strict_parameter(*args, **kwargs)
+        parameter = ::Strict::Parameter.make(*args, **kwargs)
+        __strict_dsl_internal_parameters[parameter.name] = parameter
+        nil
+      end
+
+      def method_missing(name, *args, **kwargs)
+        if respond_to_missing?(name)
+          strict_parameter(name, *args, **kwargs)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, _include_private = nil)
+        first_letter = method_name.to_s.each_char.first
+        first_letter.eql?(first_letter.downcase)
+      end
+
+      private
+
+      attr_writer :__strict_dsl_internal_returns
+    end
+  end
+end

data/lib/strict/methods/module.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Strict
+  module Methods
+    class Module < ::Module
+      attr_reader :verifiable_method
+
+      def initialize(verifiable_method)
+        super()
+
+        @verifiable_method = verifiable_method
+        define_method verifiable_method.name do |*args, **kwargs, &block|
+          args, kwargs = verifiable_method.verify_parameters!(*args, **kwargs)
+
+          super(*args, **kwargs, &block).tap do |value|
+            verifiable_method.verify_returns!(value)
+          end
+        end
+      end
+
+      def inspect
+        "#<#{self.class} (#{verifiable_method.name})>"
+      end
+    end
+  end
+end