strict 0.0.0 → 1.0.0

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,55 @@
+# 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::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

data/lib/strict/methods/verifiable_method.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Strict
+  module Methods
+    class VerifiableMethod # rubocop:disable Metrics/ClassLength
+      extend Forwardable
+
+      class UnknownParameterError < Error
+        attr_reader :parameter_name
+
+        def initialize(parameter_name:)
+          super(message_from(parameter_name:))
+
+          @parameter_name = parameter_name
+        end
+
+        private
+
+        def message_from(parameter_name:)
+          "Strict tried to find a parameter named #{parameter_name} but was unable. " \
+            "It's likely this in an internal bug, feel free to open an issue at #{Strict::ISSUE_TRACKER} for help."
+        end
+      end
+
+      def_delegator :method, :name
+
+      attr_reader :parameters, :returns
+
+      def initialize(method:, parameters:, returns:, instance:)
+        @method = method
+        @parameters = parameters
+        @parameters_index = parameters.to_h { |p| [p.name, p] }
+        @returns = returns
+        @instance = instance
+      end
+
+      def to_s
+        "#{method.owner}#{separator}#{name}"
+      end
+
+      def verify_definition!
+        expected_parameters = Set.new(parameters.map(&:name))
+        defined_parameters = Set.new(method.parameters.filter_map { |kind, name| name unless kind == :block })
+        return if expected_parameters == defined_parameters
+
+        missing_parameters = expected_parameters - defined_parameters
+        additional_parameters = defined_parameters - expected_parameters
+        raise Strict::MethodDefinitionError.new(verifiable_method: self, missing_parameters:, additional_parameters:)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
+      # TODO(kkt): clean this up- it's late, though, and the tests are passing
+      def verify_parameters!(*args, **kwargs)
+        invalid_parameters = nil
+        missing_parameters = nil
+
+        positional_arguments = []
+        keyword_arguments = {}
+
+        # TODO(kkt): doesn't handle oddly sorted optional positional parameters like def foo(opt = nil, req)
+        method.parameters.each do |kind, name|
+          case kind
+          when POSITIONAL
+            parameter_kind = :positional
+            value = args.any? ? args.shift : NOT_PROVIDED
+          when REST
+            parameter_kind = :rest
+            value = [*args]
+            args.clear
+          when KEYWORD
+            parameter_kind = :keyword
+            value = kwargs.key?(name) ? kwargs.delete(name) : NOT_PROVIDED
+          when KEYREST
+            parameter_kind = :keyrest
+            value = { **kwargs }
+            kwargs.clear
+          end
+          next unless parameter_kind
+
+          parameter = parameter_named!(name)
+          if value.equal?(NOT_PROVIDED) && parameter.optional?
+            value = parameter.default_generator.call
+          elsif value.equal?(NOT_PROVIDED)
+            missing_parameters ||= []
+            missing_parameters << parameter.name
+            next
+          end
+
+          value = parameter.coerce(value)
+          if parameter.valid?(value)
+            case parameter_kind
+            when :positional
+              positional_arguments << value
+            when :rest
+              positional_arguments.concat(value)
+            when :keyword
+              keyword_arguments[name] = value
+            when :keyrest
+              keyword_arguments.merge!(value)
+            end
+          else
+            invalid_parameters ||= {}
+            invalid_parameters[parameter] = value
+          end
+        end
+
+        if args.empty? && kwargs.empty? && invalid_parameters.nil? && missing_parameters.nil?
+          [positional_arguments, keyword_arguments]
+        else
+          raise Strict::MethodCallError.new(
+            verifiable_method: self,
+            remaining_args: args,
+            remaining_kwargs: kwargs,
+            invalid_parameters:,
+            missing_parameters:
+          )
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
+
+      def verify_returns!(value)
+        value = returns.coerce(value)
+        return if returns.valid?(value)
+
+        raise Strict::MethodReturnError.new(verifiable_method: self, value:)
+      end
+
+      private
+
+      POSITIONAL = Set.new(%i[req opt])
+      private_constant :POSITIONAL
+      REST = :rest
+      private_constant :REST
+      KEYWORD = Set.new(%i[keyreq key])
+      private_constant :KEYWORD
+      KEYREST = :keyrest
+      private_constant :KEYREST
+      NOT_PROVIDED = ::Object.new.freeze
+      private_constant :NOT_PROVIDED
+
+      attr_reader :method, :parameters_index
+
+      def instance?
+        @instance
+      end
+
+      def separator
+        instance? ? "#" : "."
+      end
+
+      def parameter_named!(name)
+        parameters_index.fetch(name) { raise UnknownParameterError.new(parameter_name: name) }
+      end
+    end
+  end
+end

data/lib/strict/object.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Strict
+  module Object
+    def self.included(mod)
+      mod.extend(Accessor::Attributes)
+    end
+  end
+end

data/lib/strict/parameter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Strict
+  class Parameter
+    NOT_PROVIDED = ::Object.new.freeze
+
+    class << self
+      def make(name, validator = Validators::Anything.instance, coerce: false, **defaults)
+        unless valid_defaults?(**defaults)
+          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)
+      end
+
+      private
+
+      def valid_defaults?(default: NOT_PROVIDED, default_value: NOT_PROVIDED, default_generator: NOT_PROVIDED)
+        defaults_provided = [default, default_value, default_generator].count do |default_option|
+          !default_option.equal?(NOT_PROVIDED)
+        end
+
+        defaults_provided <= 1
+      end
+
+      def make_default_generator(default: NOT_PROVIDED, default_value: NOT_PROVIDED, default_generator: NOT_PROVIDED)
+        if !default.equal?(NOT_PROVIDED)
+          default.respond_to?(:call) ? default : -> { default }
+        elsif !default_value.equal?(NOT_PROVIDED)
+          -> { default_value }
+        elsif !default_generator.equal?(NOT_PROVIDED)
+          default_generator
+        else
+          NOT_PROVIDED
+        end
+      end
+    end
+
+    attr_reader :name, :validator, :default_generator, :coercer
+
+    def initialize(name:, validator:, default_generator:, coercer:)
+      @name = name.to_sym
+      @validator = validator
+      @default_generator = default_generator
+      @coercer = coercer
+      @optional = !default_generator.equal?(NOT_PROVIDED)
+    end
+
+    def optional?
+      @optional
+    end
+
+    def valid?(value)
+      validator === value
+    end
+
+    def coerce(value)
+      return value unless coercer
+
+      coercer.call(value)
+    end
+  end
+end

data/lib/strict/reader/attributes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Strict
+  module Reader
+    module Attributes
+      def attributes(&block)
+        block ||= -> {}
+        configuration = Strict::Attributes::Dsl.run(&block)
+        include Module.new(configuration)
+        include Strict::Attributes::Instance
+        extend Strict::Attributes::Configured
+      end
+    end
+  end
+end

data/lib/strict/reader/module.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Strict
+  module Reader
+    class Module < ::Module
+      attr_reader :configuration
+
+      def initialize(configuration)
+        super()
+
+        @configuration = configuration
+        const_set(Strict::Attributes::Configured::CONSTANT, configuration)
+        configuration.attributes.each do |attribute|
+          module_eval(
+            "def #{attribute.name} = #{attribute.instance_variable}", # def name = @instance_variable
+            __FILE__,
+            __LINE__ - 2
+          )
+        end
+      end
+
+      def inspect
+        "#<#{self.class} (#{configuration.attributes.map(&:name).join(', ')})>"
+      end
+    end
+  end
+end

data/lib/strict/return.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Strict
+  class Return
+    class << self
+      def make(validator = Validators::Anything.instance, coerce: false)
+        new(validator:, coercer: coerce)
+      end
+    end
+
+    attr_reader :validator, :coercer
+
+    def initialize(validator:, coercer:)
+      @validator = validator
+      @coercer = coercer
+    end
+
+    def valid?(value)
+      validator === value
+    end
+
+    def coerce(value)
+      return value unless coercer
+
+      coercer.call(value)
+    end
+  end
+end

data/lib/strict/validators/all_of.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Strict
+  module Validators
+    class AllOf
+      attr_reader :subvalidators
+
+      def initialize(*subvalidators)
+        @subvalidators = subvalidators
+      end
+
+      def ===(value)
+        subvalidators.all? do |subvalidator|
+          subvalidator === value
+        end
+      end
+
+      def inspect
+        "AllOf(#{subvalidators.map(&:inspect).join(', ')})"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/strict/validators/any_of.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Strict
+  module Validators
+    class AnyOf
+      attr_reader :subvalidators
+
+      def initialize(*subvalidators)
+        @subvalidators = subvalidators
+      end
+
+      def ===(value)
+        subvalidators.any? do |subvalidator|
+          subvalidator === value
+        end
+      end
+
+      def inspect
+        "AnyOf(#{subvalidators.map(&:inspect).join(', ')})"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/strict/validators/anything.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module Strict
+  module Validators
+    class Anything
+      include Singleton
+
+      def ===(_value)
+        true
+      end
+
+      def inspect
+        "Anything()"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/strict/validators/array_of.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Strict
+  module Validators
+    class ArrayOf
+      attr_reader :element_validator
+
+      def initialize(element_validator)
+        @element_validator = element_validator
+      end
+
+      def ===(value)
+        Array === value && value.all? do |v|
+          element_validator === v
+        end
+      end
+
+      def inspect
+        "ArrayOf(#{element_validator.inspect})"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/strict/validators/boolean.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module Strict
+  module Validators
+    class Boolean
+      include Singleton
+
+      def ===(value)
+        value.equal?(true) || value.equal?(false)
+      end
+
+      def inspect
+        "Boolean()"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/strict/validators/hash_of.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Strict
+  module Validators
+    class HashOf
+      attr_reader :key_validator, :value_validator
+
+      def initialize(key_validator, value_validator)
+        @key_validator = key_validator
+        @value_validator = value_validator
+      end
+
+      def ===(value)
+        Hash === value && value.all? do |k, v|
+          key_validator === k && value_validator === v
+        end
+      end
+
+      def inspect
+        "HashOf(#{key_validator.inspect} => #{value_validator.inspect})"
+      end
+      alias to_s inspect
+    end
+  end
+end