bcdd-contract 0.1.0

data/lib/bcdd/contract/core/proxy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  class Core::Proxy
+    def self.[](object)
+      new(object)
+    end
+
+    def self.to_proc
+      ->(object) { new(object) }
+    end
+
+    attr_reader :object
+
+    def initialize(object)
+      @object = object
+    end
+  end
+end

data/lib/bcdd/contract/core.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  module Core
+    require_relative 'core/checker'
+    require_relative 'core/checking'
+    require_relative 'core/proxy'
+    require_relative 'core/factory'
+  end
+
+  private_constant :Core
+end

data/lib/bcdd/contract/interface.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  module Interface
+    module Callbacks
+      def extended(base)
+        base.singleton_class.prepend(self::Methods)
+      end
+
+      def included(base)
+        base.prepend(self::Methods)
+      end
+    end
+
+    def self.included(base)
+      base.extend(Callbacks) if Config.instance.interface_enabled
+    end
+
+    module AlwaysEnabled
+      def self.included(base)
+        base.extend(Interface::Callbacks)
+      end
+    end
+  end
+end

data/lib/bcdd/contract/list.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  class List
+    class Checking
+      include Core::Checking
+
+      def initialize(checker, value)
+        @value = value
+        @errors = []
+
+        validate(checker, @errors)
+      end
+
+      def errors_message
+        valid? ? '' : "(#{errors.join('; ')})"
+      end
+
+      private
+
+      def validate(checker, errors)
+        errors << "#{value.inspect} must be a Set | Array" and return unless value.is_a?(::Set) || value.is_a?(::Array)
+        errors << 'is empty' and return if value.empty?
+
+        value.each_with_index do |vval, index|
+          val_checking = checker[vval]
+
+          errors << "#{index}: #{val_checking.errors_message}" if val_checking.invalid?
+        end
+      end
+    end
+
+    module Checker
+      include Core::Checker
+    end
+
+    def self.new(strategy)
+      return strategy if strategy.is_a?(Checker)
+
+      Core::Factory.new(Checker, Checking, strategy)
+    end
+  end
+
+  private_constant :List
+end

data/lib/bcdd/contract/map/pairs.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  module Map::Pairs
+    class Checking
+      include Core::Checking
+
+      def initialize(schema, value)
+        @value = value
+        @errors = []
+
+        validate(schema.to_a.flatten(1), @errors)
+      end
+
+      def errors_message
+        valid? ? '' : errors.map { |msg| "(#{msg})" }.join('; ')
+      end
+
+      private
+
+      def validate(schema_key_and_value, errors)
+        skey, sval = schema_key_and_value
+
+        errors << "#{value.inspect} must be a Hash" and return unless value.is_a?(::Hash)
+        errors << 'is empty' and return if value.empty?
+
+        value.each do |vkey, vval|
+          key_checking = skey[vkey]
+
+          errors << "key: #{key_checking.errors_message}" and next if key_checking.invalid?
+
+          val_checking = sval[vval]
+
+          errors << "#{vkey}: #{val_checking.errors_message}" and next if val_checking.invalid?
+        end
+      end
+    end
+
+    module Checker
+      include Core::Checker
+    end
+
+    def self.new(strategy)
+      Core::Factory.new(Checker, Checking, strategy)
+    end
+  end
+end

data/lib/bcdd/contract/map/schema.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  module Map::Schema
+    class Checking
+      include Core::Checking
+
+      def initialize(schema, value)
+        @value = value
+        @errors = {}
+
+        validate(schema, @errors)
+      end
+
+      ErrorsMsg = ->(errors) do
+        messages = errors.map { |key, val| %(#{key}: #{val.is_a?(::Hash) ? ErrorsMsg[val] : val.join(', ')}) }
+
+        "(#{messages.join('; ')})"
+      end
+
+      def errors_message
+        valid? ? '' : ErrorsMsg[errors]
+      end
+
+      private
+
+      def validate(schema, errors)
+        errors[value.inspect] = ['must be a Hash'] and return unless value.is_a?(::Hash)
+
+        schema.each do |skey, svalue|
+          vvalue = value[skey]
+
+          vchecking = svalue[vvalue]
+
+          errors[skey] = ['must be a Hash'] and next if svalue.is_a?(Map::Schema::Checker) && !vvalue.is_a?(::Hash)
+
+          errors[skey] = vchecking.errors and next if vchecking.invalid?
+        end
+      end
+    end
+
+    module Checker
+      include Core::Checker
+    end
+
+    def self.new(strategy)
+      Core::Factory.new(Checker, Checking, strategy)
+    end
+  end
+end

data/lib/bcdd/contract/map.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  module Map
+    require_relative 'map/pairs'
+    require_relative 'map/schema'
+  end
+
+  private_constant :Map
+end

data/lib/bcdd/contract/proxy.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  # A class to inherit to create proxy objects.
+  # Which can be used to check the arguments and returned values of the proxy object's methods.
+  #
+  # @example
+  # class Calculation < ::BCDD::Contract::Proxy
+  #   ValidNumber = ::BCDD::Contract[->(value, err) do
+  #     err << '%p must be numeric' and return unless value.is_a?(::Numeric)
+  #     err << '%p cannot be nan' and return if value.respond_to?(:nan?) && value.nan?
+  #     err << '%p cannot be infinite' if value.respond_to?(:infinite?) && value.infinite?
+  #   end]
+  #
+  #   CannotBeZero = ::BCDD::Contract[->(arg, err) do
+  #     err << '%p cannot be zero' if arg.zero?
+  #   end]
+  #
+  #   def divide(a, b)
+  #     +ValidNumber[a]
+  #     +ValidNumber[b] && +CannotBeZero[b]
+  #
+  #     +ValidNumber[object.divide(a, b)]
+  #   end
+  #
+  #   # ... other methods ...
+  # end
+  class Proxy < Core::Proxy
+    # A class to inherit to create a proxy object that is always enabled.
+    AlwaysEnabled = ::Class.new(Core::Proxy)
+
+    def self.new(object)
+      return object unless Config.instance.proxy_enabled
+
+      instance = allocate
+      instance.send(:initialize, object)
+      instance
+    end
+  end
+end

data/lib/bcdd/contract/registry.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  class Registry
+    include ::Singleton
+
+    OPTIONS = ::Set[
+      UNIT = :unit,
+      LIST = :list,
+      PAIRS = :pairs,
+      SCHEMA = :schema
+    ].freeze
+
+    attr_reader :store, :names
+
+    def initialize
+      @names = {}
+
+      @store = {
+        UNIT => {},
+        LIST => {},
+        PAIRS => {},
+        SCHEMA => {}
+      }
+    end
+
+    Kind = ->(checker) do
+      case checker
+      when Unit::Checker then UNIT
+      when List::Checker then LIST
+      when Map::Pairs::Checker then PAIRS
+      when Map::Schema::Checker then SCHEMA
+      else raise ::ArgumentError, "Unknown checker type: #{checker.inspect}"
+      end
+    end
+
+    def self.write(name, checker)
+      kind = Kind[checker]
+
+      return fetch(name) if instance.names.key?(name)
+
+      instance.names[name] = kind
+
+      instance.store[kind][name] = checker
+    end
+
+    def self.fetch(name)
+      kind = instance.names[name]
+
+      kind or raise(::ArgumentError, format('%p not registered', name))
+
+      read(kind, name)
+    end
+
+    def self.unit(name)
+      read(UNIT, name)
+    end
+
+    def self.read(kind, name)
+      instance.store[kind][name]
+    end
+
+    private_class_method :read, :instance
+  end
+
+  private_constant :Registry
+end

data/lib/bcdd/contract/unit/checker.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  module Unit::Checker
+    include Core::Checker
+
+    SequenceMapper = ->(strategy1, strategy2) do
+      ->(value, err) do
+        strategy1.call(value, err)
+
+        return unless err.empty?
+
+        strategy2.call(value, err)
+      end
+    end
+
+    def &(other)
+      compose(other, SequenceMapper)
+    end
+
+    ParallelMapper = ->(strategy1, strategy2) do
+      ->(value, err) do
+        err1 = []
+        err2 = []
+
+        strategy1.call(value, err1)
+        strategy2.call(value, err2)
+
+        return if err1.empty? || err2.empty?
+
+        err << err1.concat(err2).map { |msg| format(msg, value) }.join(' OR ')
+      end
+    end
+
+    def |(other)
+      compose(other, ParallelMapper)
+    end
+
+    private
+
+    def compose(other, mapper)
+      other = Unit::Factory.build(other)
+
+      composed_strategy = mapper.call(strategy, other.strategy)
+
+      Unit::Factory.new(composed_strategy)
+    end
+
+    private_constant :SequenceMapper, :ParallelMapper
+  end
+end

data/lib/bcdd/contract/unit/factory.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  module Unit::Factory
+    def self.new(strategy)
+      Core::Factory.new(Unit::Checker, Unit::Checking, strategy)
+    end
+
+    def self.build(arg)
+      return arg if arg.is_a?(Core::Checker)
+
+      return Registry.unit(arg) if arg.is_a?(::Symbol)
+
+      return type!(::NilClass) if arg.nil?
+
+      arg.is_a?(::Proc) ? lambda!(arg) : type!(arg)
+    end
+
+    ArityOneHandler =
+      ->(strategy) do
+        ->(value, err) do
+          outcome = strategy.call(value)
+
+          err << outcome if outcome.is_a?(::String)
+        end
+      end
+
+    def self.lambda!(arg)
+      (arg.is_a?(::Proc) && arg.lambda?) or raise ::ArgumentError, 'must be a lambda'
+
+      strategy =
+        case arg.arity
+        when 1 then ArityOneHandler[arg]
+        when 2 then arg
+        else raise ::ArgumentError, 'must have two arguments (value, errors)'
+        end
+
+      new(strategy)
+    end
+
+    def self.type!(arg)
+      arg.is_a?(::Module) or raise ::ArgumentError, format('%p must be a class, module or lambda', arg)
+
+      cache_item = Registry.unit(arg)
+
+      return cache_item if cache_item
+
+      checker = lambda!(->(value, err) { err << "%p must be a #{arg.name}" unless value.is_a?(arg) })
+
+      Registry.write(arg, checker)
+    end
+  end
+end

data/lib/bcdd/contract/unit.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  # A module that can be used to create contract checkers
+  # (a module that can be used to perform validations and type checkings).
+  #
+  # @example
+  # cannot_be_inf = ->(val, err) { err << '%p cannot be infinite' if val.respond_to?(:infinite?) && val.infinite? }
+  # cannot_be_nan = ->(val, err) { err << '%p cannot be nan' if val.respond_to?(:nan?) && val.nan? }
+  #
+  # IsNumeric = ::BCDD::Contract[Numeric] & cannot_be_inf & cannot_be_nan
+  #
+  # ValidNumber = IsNumeric & CannotBeNaN & CannotBeInfinity
+  module Unit
+    class Checking
+      include Core::Checking
+
+      def initialize(strategy, value)
+        @value = value
+
+        errors = [].tap { |err| strategy.call(value, err) }
+
+        @errors = errors.flat_map { |error| format(error, value) }
+      end
+
+      def errors_message
+        errors.join(', ')
+      end
+    end
+
+    require_relative 'unit/checker'
+    require_relative 'unit/factory'
+
+    def self.new(arg)
+      Factory.build(arg)
+    end
+  end
+
+  private_constant :Unit
+end

data/lib/bcdd/contract/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module BCDD
+  module Contract
+    VERSION = '0.1.0'
+  end
+end

data/lib/bcdd/contract.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'singleton'
+
+require_relative 'contract/version'
+require_relative 'contract/core'
+require_relative 'contract/registry'
+require_relative 'contract/config'
+require_relative 'contract/unit'
+require_relative 'contract/proxy'
+require_relative 'contract/interface'
+require_relative 'contract/assertions'
+require_relative 'contract/map'
+require_relative 'contract/list'
+
+module BCDD
+  module Contract
+    class Error < StandardError; end
+
+    def self.config
+      Config.instance
+    end
+
+    def self.configuration
+      yield(config)
+
+      config.freeze
+    end
+
+    def self.proxy(always_enabled: false, &block)
+      proxy_class = always_enabled ? Proxy::AlwaysEnabled : Proxy
+
+      ::Class.new(proxy_class, &block)
+    end
+
+    def self.error!(message)
+      raise Error, message
+    end
+
+    def self.assert!(value, message, &block)
+      return value if (value && !block) || (value && block.call(value))
+
+      error!(format(message, value))
+    end
+
+    def self.refute!(value, message, &block)
+      return value if (!value && !block) || (value && block && !block.call(value))
+
+      error!(format(message, value))
+    end
+
+    def self.assert(value, ...)
+      Config.instance.assertions_enabled ? assert!(value, ...) : value
+    end
+
+    def self.refute(value, ...)
+      Config.instance.assertions_enabled ? refute!(value, ...) : value
+    end
+
+    def self.new(arg)
+      return arg if arg.is_a?(Core::Checker)
+
+      return schema(arg) if arg.is_a?(::Hash)
+
+      return Registry.fetch(arg) if arg.is_a?(::Symbol)
+
+      return unit(arg) unless arg.is_a?(::Array) || arg.is_a?(::Set)
+
+      list = arg.to_a.flatten
+
+      return list(list[0]) if list.size == 1
+
+      raise ::ArgumentError, 'must be one contract checker'
+    end
+
+    singleton_class.send(:alias_method, :[], :new)
+
+    def self.to_proc
+      ->(arg) { self[arg] }
+    end
+
+    def self.register(**kargs)
+      kargs.empty? and raise ::ArgumentError, 'must be passed as keyword arguments'
+
+      kargs.each_with_object({}) do |(key, val), memo|
+        memo[key] = Registry.write(key, new(val))
+      end
+    end
+
+    def self.unit(arg)
+      Unit.new(arg)
+    end
+
+    def self.list(arg)
+      List.new(new(arg))
+    end
+
+    def self.schema(arg)
+      arg.is_a?(::Hash) or raise ::ArgumentError, 'must be a Hash'
+
+      Map::Schema.new(arg.transform_values { |svalue| new(svalue) })
+    end
+
+    def self.pairs(arg)
+      arg.is_a?(::Hash) or raise ::ArgumentError, 'must be a Hash'
+      arg.keys.size == 1 or raise ::ArgumentError, 'must have only one key and value'
+
+      key, val = arg.to_a.flatten(1)
+
+      Map::Pairs.new(new(key) => new(val))
+    end
+  end
+
+  def self.Contract(arg)
+    Contract.new(arg)
+  end
+end

data/lib/bcdd-contract.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bcdd/contract'

data/sig/bcdd/contract/assertions.rbs

@@ -0,0 +1,7 @@
+module BCDD::Contract::Assertions
+  def assert!: (untyped, String) { (untyped) -> bool } -> untyped
+  def refute!: (untyped, String) { (untyped) -> bool } -> untyped
+
+  def assert: (untyped, String) { (untyped) -> bool } -> untyped
+  def refute: (untyped, String) { (untyped) -> bool } -> untyped
+end

data/sig/bcdd/contract/config.rbs

@@ -0,0 +1,15 @@
+module BCDD::Contract
+  class Config
+    include ::Singleton
+
+    attr_accessor proxy_enabled: bool
+    attr_accessor interface_enabled: bool
+    attr_accessor assertions_enabled: bool
+
+    def self.instance: () -> Config
+
+    def initialize: () -> void
+
+    def options: () -> Hash[Symbol, bool]
+  end
+end

data/sig/bcdd/contract/core.rbs

@@ -0,0 +1,60 @@
+module BCDD::Contract
+  module Core
+    class Proxy
+      attr_reader object: untyped
+
+      def self.new: (untyped) -> Proxy
+
+      def self.to_proc: () -> Proc
+
+      def initialize: (untyped) -> Proxy
+    end
+
+    module Checking
+      attr_reader errors: ::Array[::String]
+
+      attr_reader value: untyped
+
+      def initialize: (untyped, untyped) -> void
+
+      def valid?: () -> bool
+      def invalid?: () -> bool
+
+      alias errors? invalid?
+
+      def errors_message: () -> ::String
+
+      def raise_validation_errors!: () -> void
+
+      def value_or_raise_validation_errors!: () -> untyped
+
+      alias value! value_or_raise_validation_errors!
+      alias assert! value_or_raise_validation_errors!
+    end
+
+    module Checker
+      def []: (untyped) -> Checking
+
+      def ===: (untyped) -> bool
+
+      def to_proc: () -> ::Proc
+
+      def invariant: (untyped) { (untyped) -> untyped } -> untyped
+
+      def checking: () -> untyped
+
+      def strategy: () -> untyped
+
+      def const_get: (untyped, bool) -> untyped
+    end
+
+    module Factory
+      module Callbacks
+        def included: (untyped) -> void
+        def extended: (untyped) -> void
+      end
+
+      def self.new: (untyped, untyped, untyped) -> ::Module
+    end
+  end
+end

data/sig/bcdd/contract/interface.rbs

@@ -0,0 +1,12 @@
+module BCDD::Contract::Interface
+  module Callbacks
+    def self.included: (untyped) -> void
+    def self.extended: (untyped) -> void
+  end
+
+  def self.included: (untyped) -> void
+
+  module AlwaysEnabled
+    def self.included: (untyped) -> void
+  end
+end