ree 1.0.0

data/lib/ree/contracts/called_args_validator.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class CalledArgsValidator
+    class ArgContract < Struct.new(:type, :contract, :arg); end
+    class Arg < Struct.new(:name, :type, :validator, :contract); end
+
+    attr_reader :contracts, :block_contract, :params, :printed_name
+    
+    def initialize(contract, params, printed_name)
+      @contracts = contract.arg_contracts
+      @block_contract = contract.block_contract
+      @params = params
+      @printed_name = printed_name
+      @args = {}
+      build_args
+    end
+
+    def get_args
+      @args
+    end
+    
+    def get_arg(arg_name)
+      @args[arg_name]
+    end
+
+    def call(args, kwargs, blk)
+      if block_contract == ArgContracts::Block && !blk
+        msg = "missing required block"
+        raise ContractError, "Wrong number of arguments for #{printed_name}\n\t - #{msg}"
+      end
+
+      errors = []
+
+      validate_args(args, errors)
+      validate_kwargs(kwargs, errors)
+
+      return if errors.empty?
+
+      msg = error_message(errors)
+      puts(colorize(msg))
+
+      raise ContractError, msg
+    end
+
+    private
+
+    def colorize(str)
+      "\e[31m#{str}\e[0m"
+    end
+
+    def build_args
+      ordinary_args = params.select { |type, _| type == :req || type == :opt }
+      all_keyword_args = params.select { |type, _| type == :keyreq || type == :key }
+      opt_keyword_args = params.select { |type, _| type == :key }
+      ksplat_arg = params.detect { |type, _| type == :keyrest }
+      splat_arg = params.detect { |type, _| type == :rest }
+
+      kwarg_contract = contracts.detect { _1.is_a?(ArgContracts::Kwargs) }
+      splat_contract = contracts.detect { _1.is_a?(ArgContracts::Splat) }
+      ksplat_contract = contracts.detect { _1.is_a?(ArgContracts::Ksplat) }
+      default_msg = "Contract definition mismatches method definition for #{printed_name}"
+
+      @ksplat_contract = ksplat_contract
+      @kwarg_contract = kwarg_contract
+
+      if !opt_keyword_args.empty?
+        if kwarg_contract.nil?
+          msgs = [default_msg]
+          msgs << "\t - methods with optional keyword arguments should use Kwargs[...] to describe all keyword args"
+          raise BadContractError, msgs.join("\n")
+        else
+          missing_keys = all_keyword_args.map { _2 } - kwarg_contract.keys
+
+          if !missing_keys.empty?
+            msgs = [default_msg]
+
+            missing_keys.each do |key|
+              msgs << "\t - missing Kwargs contract for keyword argument `#{key}`"
+            end
+            raise BadContractError, msgs.join("\n")
+          end
+        end
+      elsif kwarg_contract && all_keyword_args.empty?
+        msgs = [default_msg]
+        msgs << "\t - Kwargs contract should be used to describe keyword arguments only"
+        raise BadContractError, msgs.join("\n")
+      end
+      
+      arg_contracts = []
+      
+      contracts.each do |contract|        
+        next if contract.is_a?(ArgContracts::None)
+
+        if contract.is_a?(ArgContracts::Kwargs)
+          contract.each do |key, cont|
+            arg_contracts << ArgContract.new(:key, contract, key)
+          end
+        elsif contract.is_a?(ArgContracts::SplatOf)
+          arg_contracts << ArgContract.new(:splat, contract, nil)
+        elsif contract.is_a?(ArgContracts::Splat)
+          arg_contracts << ArgContract.new(:splat, contract, nil)
+        elsif contract.is_a?(ArgContracts::Ksplat)
+          arg_contracts << ArgContract.new(:ksplat, contract, nil)
+        else
+          arg_contracts << ArgContract.new(:ord, contract, nil)
+        end
+      end
+
+      if block_contract
+        arg_contracts << ArgContract.new(:block, block_contract, nil)
+      end
+
+      if arg_contracts.size != params.size
+        msgs = [default_msg]
+        msgs << "\t - contract count is not equal to argument count"
+        msgs << "\t - contract count: #{arg_contracts.size}"
+        msgs << "\t - argument count: #{params.size}"
+        raise BadContractError, msgs.join("\n")
+      end
+
+      arg_contracts.each_with_index do |arg_contract, index|
+        type, name = params[index]
+
+        validator, contract = if (type == :req || type == :opt)
+          if arg_contract.type == :ord
+            [Validators.fetch_for(arg_contract.contract), arg_contract.contract]
+          end
+        elsif type == :key || type == :keyreq
+          if arg_contract.type == :key
+            [Validators.fetch_for(arg_contract.contract[name]), arg_contract.contract[name]]
+          elsif arg_contract.type == :ord
+            [Validators.fetch_for(arg_contract.contract), arg_contract.contract]
+          end
+        elsif type == :rest 
+          if arg_contract.type == :splat
+            [Validators.fetch_for(arg_contract.contract), arg_contract.contract]
+          end
+        elsif type == :keyrest
+          if arg_contract.type == :ksplat
+            [Validators.fetch_for(arg_contract.contract), arg_contract.contract]
+          end
+        elsif type == :block
+          if arg_contract.type == :block
+            [nil, arg_contract.contract]
+          end
+        else
+          raise NotImplementedError, "type `#{type}` is not supported. Message gem owner to add it :)"
+        end
+
+        if validator.nil? && contract.nil?
+          msgs = [default_msg]
+          msgs << "\t - invalid contract for `#{name}` argument => #{arg_contract.contract.inspect}"
+          raise BadContractError, msgs.join("\n")
+        end
+
+        @args[name] = Arg.new(name, type, validator, contract)
+      end
+    end
+
+    def validate_kwargs(kwargs, errors)
+      extra_keys = kwargs.keys - key_params.map { _1.last }
+
+      if !extra_keys.empty? && !ksplat_arg
+        msgs = []
+
+        extra_keys.each do |key|
+          msgs << "\t - unknown keyword arg `#{key}`"
+        end
+
+        raise ContractError, "Wrong number of arguments for #{printed_name}\n#{msgs.join("\n")}"
+      end
+
+      key_params.each do |type, name|
+        if type == :keyreq && !kwargs.has_key?(name)
+          msg = "missing keyword arg `#{name}`"
+          raise ContractError, "Wrong number of arguments for #{printed_name}\n\t - #{msg}"
+        end
+
+        next if type == :key && !kwargs.has_key?(name)
+
+        arg = @args.fetch(name)
+        arg_value = kwargs.fetch(name)
+        
+        next if arg.validator.call(arg_value)
+
+        errors << [name, arg.contract, arg_value]
+      end
+
+      if ksplat_arg && !extra_keys.empty?
+        key = ksplat_arg.last
+        arg = @args.fetch(key)
+        value = {}
+
+        extra_keys.each do |key|
+          value.store(key, kwargs[key])
+        end
+
+        if !arg.validator.call(value)
+          errors << [key, arg.contract, value]
+        end
+      end
+    end
+
+    def validate_args(args, errors)
+      args = args.dup
+      args_number = args.size
+      assigned_args = {}
+      
+      # validate req args before opt/splat
+      arg_params.each do |(type, name)|
+        break if type != :req
+
+        if args.size == 0
+          msg = "missing value for `#{name}`"
+          raise ContractError, "Wrong number of arguments for #{printed_name}\n\t - #{msg}"
+        end
+
+        assigned_args[name] = true
+        arg_value = args.shift
+        arg = @args[name]
+        errors << [name, arg.contract, arg_value] unless arg.validator.call(arg_value)
+      end
+
+      # validate req args after opt/splat
+      arg_params.reverse_each.with_index(1) do |(type, name), idx|
+        break if type != :req
+        break if assigned_args[name]
+
+        if args.size == 0
+          msg = "missing value for `#{name}`"
+          raise ContractError, "Wrong number of arguments for #{printed_name}\n\t - #{msg}"
+        end
+        
+        arg_value = args.pop
+        arg = @args[name]
+        errors << [name, arg.contract, arg_value] unless arg.validator.call(arg_value)
+      end unless args.empty?
+
+      # validate opt args
+      arg_params.each_with_index do |(type, name), idx|
+        break if args.empty?
+        next if type != :opt
+
+        arg_value = args.shift
+        arg = @args[name]
+        errors << [name, arg.contract, arg_value] unless arg.validator.call(arg_value)
+      end
+
+      if !splat_arg && args.size > 0
+        msg = "given #{args_number}, expected #{arg_params.size}"
+        raise ContractError, "Wrong number of arguments for #{printed_name}\n\t - #{msg}"
+      end
+
+      if splat_arg
+        name = splat_arg.last
+        arg = @args[name]
+        errors << [name, arg.contract, args] unless arg.validator.call(args)
+      end
+    end
+
+    def splat_arg
+      @splat_arg ||= params.detect { |type, _| type == :rest }
+    end
+
+    def ksplat_arg
+      @ksplat_arg ||= params.detect { |type, _| type == :keyrest }
+    end
+
+    def arg_params
+      @arg_params ||= params.select { |type, _| type == :req || type == :opt }
+    end
+
+    def key_params
+      @key_params ||= params.select { |type, _| type == :keyreq || type == :key }
+    end
+
+    def error_message(errors)
+      msgs = ["Contract violation for #{printed_name}"]
+
+      errors.each do |name, cont, val|
+        validator = Validators.fetch_for(cont)
+        msg = validator.message(val, name)
+        sps = msg.lines.one? ? ' ' : ''
+        msgs << "\t - #{name}:#{sps}#{msg}"
+      end
+
+      msgs.join("\n")
+    end
+  end
+end

data/lib/ree/contracts/contract_definition.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class ContractDefinition
+    attr_reader :arg_contracts, :return_contract, :block_contract
+    
+    def initialize(contract)
+      @arg_contracts, @return_contract = split_contract(contract)
+      @block_contract = arg_contracts.pop if ArgContracts.opt_or_block?(arg_contracts.last)
+
+      validate_block_contract
+      validate_return_contract
+      validate_kwargs_contract
+      validate_splat_contract
+      validate_ksplat_contract
+      validate_dependent_contracts
+    end
+
+    private
+
+    def validate_dependent_contracts
+      splat_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::Splat) }
+      splat_of_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::SplatOf) }
+      kwargs_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::Kwargs) }
+      ksplat_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::Ksplat) }
+
+      if splat_index && kwargs_index && splat_index > kwargs_index
+        raise BadContractError, "Splat contract should go before Kwargs"
+      end
+
+      if splat_of_index && kwargs_index && splat_of_index > kwargs_index
+        raise BadContractError, "SplatOf contract should go before Kwargs"
+      end
+
+      if splat_index && ksplat_index && splat_index > ksplat_index
+        raise BadContractError, "Splat contract should go before Ksplat"
+      end
+
+      if ksplat_index && kwargs_index && ksplat_index < kwargs_index
+        raise BadContractError, "Ksplat contract should go after Kwargs"
+      end
+    end
+
+    def validate_splat_contract
+      splat_cont_number = arg_contracts.count { |cont| cont.is_a?(ArgContracts::Splat) }
+
+      if splat_cont_number > 1
+        raise BadContractError, "Multiple Splat contracts are not allowed"
+      end
+
+      splat_of_cont_number = arg_contracts.count { |cont| cont.is_a?(ArgContracts::SplatOf) }
+
+      if splat_of_cont_number > 1
+        raise BadContractError, "Multiple SplatOf contracts are not allowed"
+      end
+    end
+
+    def validate_ksplat_contract
+      ksplat_cont_number = arg_contracts.count { |cont| cont.is_a?(ArgContracts::Ksplat) }
+
+      if ksplat_cont_number > 1
+        raise BadContractError, "Multiple Ksplat contracts are not allowed"
+      end
+
+      kwargs = arg_contracts.detect { |cont| cont.is_a?(ArgContracts::Kwargs) }
+      ksplat = arg_contracts.detect { |cont| cont.is_a?(ArgContracts::Ksplat) }
+
+      if kwargs && ksplat
+        keys = kwargs.contracts.keys & ksplat.validators.keys
+      
+        if keys.size > 0
+          raise BadContractError, "Ksplat & Kwargs contracts has same keys #{keys.inspect}"
+        end
+      end
+    end
+
+    def validate_kwargs_contract
+      kwargs_cont_number = arg_contracts.count { |cont| cont.is_a?(ArgContracts::Kwargs) }
+
+      if kwargs_cont_number > 1
+        raise BadContractError, "Only one Kwargs contract could be provided"
+      end
+
+      kwargs_cont_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::Kwargs) }
+      ksplat_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::Ksplat) }
+      splat_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::Splat) }
+      splat_of_index = arg_contracts.index { |cont| cont.is_a?(ArgContracts::SplatOf) }
+
+      if kwargs_cont_index && !ksplat_index && !splat_index && !splat_of_index
+        return if kwargs_cont_index == arg_contracts.size - 1
+        raise BadContractError, 'Kwargs contract should appear in the end'
+      end
+    end
+
+    FORBIDDEN_RETURN_CONTRACTS = [
+      ArgContracts::None, ArgContracts::Kwargs,
+      ArgContracts::Block, ArgContracts::Optblock,
+      ArgContracts::Splat, ArgContracts::Ksplat
+    ]
+
+    def validate_return_contract
+      return if !FORBIDDEN_RETURN_CONTRACTS.include?(return_contract) && !FORBIDDEN_RETURN_CONTRACTS.include?(return_contract.class)
+      raise BadContractError, "Contract for return value does not support None, Kwargs, Block, Optblock, Splat, Ksplat"
+    end
+
+    def validate_block_contract
+      block_cont_idx = arg_contracts.index { |cont| ArgContracts.opt_or_block?(cont) }
+      return if !block_cont_idx
+      raise BadContractError, 'Block (Optblock) contract should appear in the end'
+    end
+
+    def split_contract(contract)
+      last_contract = contract.last
+      
+      if last_contract.is_a?(Hash) && last_contract.one?
+        last_arg_contract, return_contract = last_contract.first
+
+        arg_contracts = contract[0..-2] + [last_arg_contract]
+
+        if arg_contracts.any? { |cont| cont == ArgContracts::None }
+          if arg_contracts.size > 1
+            raise BadContractError, 'Combination of None contract with other contracts is not allowed'
+          end
+
+          arg_contracts = []
+        end
+
+        return [arg_contracts, return_contract]
+      end
+
+      return [[], contract.first] if contract.one?
+
+      raise BadContractError, <<~STR
+        It looks like your contract doesn't have a return value.
+        A contract should be written as
+          `contract arg1, arg2 => return_value`
+        or
+          `contract return_value`.
+      STR
+    end
+  end
+end

data/lib/ree/contracts/contractable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'method_decorator'
+require_relative 'engine'
+require_relative 'engine_proxy'
+
+module Ree::Contracts
+  module Contractable
+    if !Ree::Contracts.no_contracts?
+      def method_added(name)
+        MethodDecorator.new(name, false, self).call
+        super
+      end
+
+      def singleton_method_added(name)
+        MethodDecorator.new(name, true, self).call
+        super
+      end
+    end
+
+    def doc(str)
+      return if Ree::Contracts.no_contracts?
+      
+      engine = Engine.fetch_for(self)
+      engine.add_doc(str.strip)
+    end
+
+    def contract(*args, &block)
+      engine = Engine.fetch_for(self)
+      engine.add_contract(*args, &block)
+      EngineProxy.new(engine)
+    end
+  end
+end

data/lib/ree/contracts/core.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module Core
+    def self.included(base)
+      common(base)
+    end
+
+    def self.extended(base)
+      common(base)
+    end
+
+    def self.common(base)
+      base.extend(Contractable)
+    end
+  end
+end

data/lib/ree/contracts/engine.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class Engine
+    class << self
+      def fetch_for(target)
+        engines[target.object_id] ||= new(target)
+      end
+
+      private
+
+      def engines
+        @engines ||= {}
+      end
+    end
+
+    include Ree::Args
+
+    attr_reader :target
+
+    def initialize(target)
+      check_arg_any(target, :target, [Class, Module])
+      @target = target
+    end
+
+    def add_contract(*args)
+      if @contract
+        raise Ree::Error.new('Another active contract definition found', :invalid_dsl_usage)
+      end
+
+      @contract = ContractDefinition.new(args)
+    end
+
+    def add_doc(str)
+      check_arg(str, :str, String)
+
+      if @doc
+        raise Ree::Error.new('Another active contract definition found', :invalid_dsl_usage)
+      end
+
+      @doc = str
+    end
+
+    def add_errors(*errors)
+      if @errors
+        raise Ree::Error.new('Another active contract definition found', :invalid_dsl_usage)
+      end
+
+      errors.each do |e|
+        check_arg(e, :errors, Class)
+      end
+
+      @errors = errors
+    end
+
+    def fetch_doc
+      doc, @doc = @doc, nil
+      doc
+    end
+
+    def fetch_contract
+      contract, @contract = @contract, nil
+      contract
+    end
+
+    def fetch_errors
+      errors, @errors = @errors, nil
+      errors
+    end
+  end
+end

data/lib/ree/contracts/engine_proxy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class EngineProxy
+    def initialize(engine)
+      @engine = engine
+    end
+
+    def throws(*errors)
+      @engine.add_errors(*errors)
+    end
+  end
+end

data/lib/ree/contracts/errors/bad_contract_error.rb

@@ -0,0 +1,4 @@
+module Ree::Contracts
+  class BadContractError < Error
+  end
+end

data/lib/ree/contracts/errors/contract_error.rb

@@ -0,0 +1,4 @@
+module Ree::Contracts
+  class ContractError < Error
+  end
+end

data/lib/ree/contracts/errors/error.rb

@@ -0,0 +1,4 @@
+module Ree::Contracts
+  class Error < StandardError
+  end
+end

data/lib/ree/contracts/errors/return_contract_error.rb

@@ -0,0 +1,4 @@
+module Ree::Contracts
+  class ReturnContractError < ContractError
+  end
+end