strict 0.0.0 → 1.1.0

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::Class
+      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::Class::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

data/lib/strict/validators/range_of.rb

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

data/lib/strict/value.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Strict
+  module Value
+    def self.included(mod)
+      mod.extend(Reader::Attributes)
+    end
+
+    def with(**attributes)
+      self.class.new(**to_h.merge(attributes))
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) && to_h.eql?(other.to_h)
+    end
+    alias == eql?
+
+    def hash
+      [self.class, to_h].hash
+    end
+  end
+end

data/lib/strict/version.rb

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

data/lib/strict.rb

@@ -5,4 +5,5 @@ loader = Zeitwerk::Loader.for_gem
 loader.setup
 
 module Strict
+  ISSUE_TRACKER = "https://github.com/kylekthompson/strict/issues"
 end

data/strict.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/strict/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "strict"
+  spec.version = Strict::VERSION
+  spec.authors = ["Kyle Thompson"]
+  spec.email = ["me@kkt.dev"]
+
+  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.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.add_development_dependency "debug", ">= 1.0.0"
+  spec.add_development_dependency "gem-release", "~> 2.2"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-spec-context", "~> 0.0.4"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+  spec.add_development_dependency "rubocop-minitest", "~> 0.22"
+  spec.add_development_dependency "rubocop-rake", "~> 0.6"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strict
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Kyle Thompson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-01 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: gem-release
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-spec-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +108,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 description:
 email:
 - me@kkt.dev
@@ -96,9 +152,48 @@ files:
 - README.md
 - Rakefile
 - lib/strict.rb
+- lib/strict/accessor/attributes.rb
+- 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/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
+- lib/strict/method_return_error.rb
+- lib/strict/methods/configuration.rb
+- lib/strict/methods/dsl.rb
+- lib/strict/methods/module.rb
+- lib/strict/methods/verifiable_method.rb
+- lib/strict/object.rb
+- lib/strict/parameter.rb
+- lib/strict/reader/attributes.rb
+- lib/strict/reader/module.rb
+- lib/strict/return.rb
+- lib/strict/validators/all_of.rb
+- lib/strict/validators/any_of.rb
+- lib/strict/validators/anything.rb
+- lib/strict/validators/array_of.rb
+- lib/strict/validators/boolean.rb
+- lib/strict/validators/hash_of.rb
+- lib/strict/validators/range_of.rb
+- lib/strict/value.rb
 - lib/strict/version.rb
 - sig/strict.rbs
+- strict.gemspec
 homepage: https://github.com/kylekthompson/strict
 licenses:
 - MIT