ree 1.0.0

data/lib/ree/contracts/method_decorator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class MethodDecorator
+    class << self
+      def decorator_id(target, method_name, is_class_method)
+        "#{target.object_id}#{target.name}#{method_name}#{is_class_method}"
+      end
+
+      def add_decorator(decorator)
+        decorators[decorator.id] = decorator
+      end
+
+      def get_decorator(id)
+        decorators[id]
+      end
+
+      def decorators
+        @decorators ||= {}
+      end
+    end
+
+    include Ree::Args
+    
+    attr_reader :target # [Class] class ot superclass of decorated method
+    attr_reader :method_name # [Symbol] original method name
+    attr_reader :method_parameters # [Array] list of original method parameters
+    attr_reader :is_class_method # [Bool]
+    attr_reader :contract_definition # [ContractDefinition] definition of contract
+    attr_reader :errors # [Nilor[ArrayOf[Class]]] list of thrown errors
+    attr_reader :doc # [Nilor[String]] rdoc
+    attr_reader :args # [CalledArgsValidator]
+    attr_reader :return_validator # [BaseValidator] validator for return value
+
+    def initialize(method_name, is_class_method, target)
+      check_arg(method_name, :method_name, Symbol)
+      check_bool(is_class_method, :is_class_method)
+      check_arg_any(target, :target, [Class, Module])
+
+      engine = Engine.fetch_for(target)
+
+      @method_name = method_name
+      @is_class_method = is_class_method
+      @target = target
+      @contract_definition = engine.fetch_contract
+      @errors = engine.fetch_errors
+      @doc = engine.fetch_doc
+    end
+
+    def call
+      return if Ree::Contracts.no_contracts?
+      return unless contract_definition
+
+      self.class.add_decorator(self)
+
+      @method_parameters = alias_target
+        .instance_method(method_name)
+        .parameters
+        .freeze
+
+      @args = CalledArgsValidator.new(
+        contract_definition,
+        method_parameters,
+        printed_name
+      )
+
+      @return_validator = Validators.fetch_for(contract_definition.return_contract)
+
+      make_alias
+      make_definition
+    end
+
+    def execute_on(target, args, kwargs, &blk)
+      @args.call(args, kwargs, blk)
+      result = target.send(method_alias, *args, **kwargs, &blk)
+
+      if !return_validator.call(result)
+        raise ReturnContractError, "Invalid return value for #{printed_name}\n  #{
+          return_validator.message(result, 'returns', 0).strip
+        }"
+      end
+
+      result
+    end
+
+    # Unique ID of this Method Decorator
+    def id
+      @id ||= self.class.decorator_id(target, method_name, is_class_method)
+    end
+
+    # Alias name for original method
+    def method_alias
+      @method_alias ||= :"__original_#{method_name}_#{SecureRandom.hex}"
+    end
+
+    # Target class to be used for alias method definition
+    def alias_target
+      @alias_target ||= begin
+        return Utils.eigenclass_of(target) if is_class_method
+        target
+      end
+    end
+
+    private
+
+    def make_alias
+      alias_target.alias_method(method_alias, method_name)
+    end
+
+    def make_definition
+      file, line = alias_target.instance_method(method_alias).source_location
+
+      alias_target.class_eval(%Q(
+        def #{method_name}(*args, **kwargs, &blk)
+          decorator = Ree::Contracts::MethodDecorator.get_decorator('#{id}')
+          decorator.execute_on(self, args, kwargs, &blk)
+        end
+      ), file, line - 3)
+
+      make_private if private_method?
+      make_protected if protected_method?
+    end
+
+    def private_method?
+      return target.private_methods.include?(method_alias) if is_class_method
+      target.private_instance_methods.include?(method_alias)
+    end
+
+    def protected_method?
+      return target.protected_methods.include?(method_alias) if is_class_method
+      target.protected_instance_methods.include?(method_alias)
+    end
+
+    def make_private
+      _method_name = method_name
+      _method_alias = method_alias
+
+      alias_target.class_eval do
+        private _method_name
+        private _method_alias
+      end
+    end
+
+    def make_protected
+      _method_name = method_name
+      _method_alias = method_alias
+
+      alias_target.class_eval do
+        protected _method_name
+        protected _method_alias
+      end
+    end
+
+    def printed_name
+      @printed_name ||= "#{target}#{is_class_method ? '.' : '#'}#{method_name}"
+    end
+  end
+end

data/lib/ree/contracts/truncatable.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module Truncatable
+    def truncate(str, limit = 80)
+      str.length > limit ? "#{str[0..limit]}..." : str
+    end
+  end
+end

data/lib/ree/contracts/utils.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module Utils
+    def self.eigenclass_of(target)
+      class << target; self; end
+    end
+  end
+end

data/lib/ree/contracts/validators/array_validator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class ArrayValidator < BaseValidator
+    attr_reader :validators
+
+    def initialize(contract)
+      super(contract)
+      @validators = contract.map { |cont| Validators.fetch_for(cont) }
+    end
+
+    def to_s
+      "[#{validators.map(&:to_s).join(', ')}]"
+    end
+
+    def call(value)
+      return false unless value.is_a?(Array) && value.length == validators.length
+
+      value.zip(validators).all? do |val, validator|
+        validator.call(val)
+      end
+    end
+
+    def message(value, name, lvl = 1)
+      unless value.is_a?(Array)
+        return "expected Array, got #{value.class} => #{truncate(value.inspect)}"
+      end
+
+      unless value.length == validators.length
+        return "expected to have #{validators.length} #{pluralize(validators.length, 'item', 'items')}, got #{value.length} #{pluralize(value.length, 'item', 'items')} => #{truncate(value.inspect)}"
+      end
+
+      errors = []
+      sps = "  " * lvl
+
+      value.zip(validators).each_with_index do |(val, validator), idx|
+        next if validator.call(val)
+
+        msg = validator.message(val, "#{name}[#{idx}]", lvl + 1)
+        errors << "\n\t#{sps} - #{name}[#{idx}]: #{msg}"
+
+        if errors.size > 3
+          errors << "\n\t#{sps} - ..."
+          break
+        end
+      end
+
+      errors.join
+    end
+  end
+end

data/lib/ree/contracts/validators/base_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class BaseValidator
+    include Ree::Contracts::Truncatable
+
+    attr_reader :contract
+    
+    def initialize(contract)
+      @contract = contract
+    end
+
+    def to_s
+      raise NotImplementedError
+    end
+
+    def call(value)
+      raise NotImplementedError
+    end
+
+    private
+
+    def pluralize(num, single, plural)
+      num == 1 ? single : plural
+    end
+  end
+end

data/lib/ree/contracts/validators/class_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class ClassValidator < BaseValidator
+    def call(value)
+      value.is_a?(contract)
+    end
+
+    def to_s
+      contract.name
+    end
+
+    def message(value, _name, _lvl = 1)
+      "expected #{contract}, got #{value.class} => #{truncate(value.inspect)}"
+    end
+  end
+end

data/lib/ree/contracts/validators/default_validator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class DefaultValidator < BaseValidator
+    def call(value)
+      contract == value
+    end
+
+    def to_s
+      truncate(
+        contract.respond_to?(:to_s) ? contract.to_s : contract.inspect,
+        10
+      )
+    end
+
+    def message(value, _name, _lvl = 1)
+      "expected #{truncate(contract.inspect, 40)}, got #{truncate(value.inspect, 40)}"
+    end
+  end
+end

data/lib/ree/contracts/validators/hash_validator.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ree::Contracts
+  class HashValidator < BaseValidator
+    attr_reader :opt_dict, :validators
+
+    def initialize(contract)
+      super(contract)
+
+      @opt_dict = Set.new
+
+      @validators = contract
+        .transform_values { |cont| Validators.fetch_for(cont) }
+        .transform_keys { |key|
+          next key unless key.is_a?(String) || key.is_a?(Symbol)
+
+          key_str = key.to_s
+          next key unless key_str.end_with?('?') && key_str.length > 1
+
+          opt_key = key_str[0..-2]
+          opt_key = opt_key.to_sym if key.is_a? Symbol
+          @opt_dict << opt_key
+
+          opt_key
+        }
+    end
+
+    def call(value)
+      return false unless value.is_a?(Hash)
+      return false unless value.all? { |key, _| validators.has_key?(key) }
+
+      validators.all? do |key, validator|
+        value.has_key?(key) ? validator.call(value[key]) : optional?(key)
+      end
+    end
+
+    def to_s
+      "{#{validators.map { |k, v| "#{key_to_s(k)} => #{v.to_s}" }.join(', ')}}"
+    end
+
+    def message(value, name, lvl = 1)
+      unless value.is_a?(Hash)
+        return "expected Hash, got #{value.class} => #{truncate(value.inspect)}"
+      end
+
+      errors = []
+      sps = "  " * lvl
+
+      validators.each do |key, validator|
+        if errors.size > 3
+          errors << "\n\t#{sps} - ..."
+          break
+        end
+
+        unless value.key?(key)
+          errors << "\n\t#{sps} - #{name}[#{key.inspect}]: missing" unless optional?(key)
+          next
+        end
+
+        val = value[key]
+        next if validator.call(val)
+
+        msg = validator.message(val, "#{name}[#{key.inspect}]", lvl + 1)
+        errors << "\n\t#{sps} - #{name}[#{key.inspect}]: #{msg}"
+      end
+
+      value.each do |key, val|
+        if errors.size > 3
+          errors << "\n\t#{sps} - ..."
+          break
+        end
+
+        next if validators.key?(key)
+
+        errors << "\n\t#{sps} - #{name}[#{key.inspect}]: unexpected"
+      end
+
+      errors.join
+    end
+
+    private
+
+    def key_to_s(key)
+      k =if optional?(key)
+        v = "#{key}?"
+        key.is_a?(String) ? v : v.to_sym
+      else
+        key
+      end
+
+      k.inspect
+    end
+
+    def optional?(key)
+      opt_dict.include?(key)
+    end
+  end
+end

data/lib/ree/contracts/validators/proc_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class ProcValidator < BaseValidator
+    def call(value)
+      contract.call value
+    end
+
+    def to_s
+      'Proc#call'
+    end
+
+    def message(value, name, lvl = 1)
+      "proc validation failed for #{truncate(value.inspect)}"
+    end
+  end
+end

data/lib/ree/contracts/validators/range_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class RangeValidator < BaseValidator
+    def call(value)
+      contract.include? value
+    end
+
+    def to_s
+      contract.inspect
+    end
+
+    def message(value, _name, _lvl = 1)
+      "expected value to be in range #{contract}, got #{truncate(value.inspect)}"
+    end
+  end
+end

data/lib/ree/contracts/validators/regexp_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class RegexpValidator < BaseValidator
+    def call(value)
+      value =~ contract
+    end
+
+    def to_s
+      contract.to_s
+    end
+
+    def message(value, name, lvl = 1)
+      "expected to match #{contract.to_s}, got #{truncate(value.inspect)}"
+    end
+  end
+end

data/lib/ree/contracts/validators/valid_validator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  class ValidValidator < BaseValidator
+    def call(value)
+      contract.valid? value
+    end
+
+    def to_s
+      if contract.respond_to?(:to_s)
+        contract.to_s
+      else
+        klass = contract.is_a?(Class) ? contract : contract.class
+        klass.name
+      end
+    end
+
+    def message(value, name, lvl = 1)
+      if contract.respond_to?(:message)
+        contract.message(value, name, lvl)
+      else
+        obj_name = contract.is_a?(Class) ? contract : contract.class
+        op = contract.is_a?(Class) ? '.' : '#'
+        "#{obj_name}#{op}valid? failed for #{truncate(value.inspect)}"
+      end
+    end
+  end
+end

data/lib/ree/contracts/validators.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ree::Contracts
+  class Validators
+    FORBIDDEN_CONTRACTS = Set.new([
+      ArgContracts::None, ArgContracts::Kwargs,
+      ArgContracts::Block, ArgContracts::Optblock,
+      ArgContracts::SplatOf, ArgContracts::Splat
+    ])
+
+    class << self
+      def fetch_for(contract)
+        validators[contract.object_id] ||= build(contract)
+      end
+
+      private
+
+      def build(contract)
+        if FORBIDDEN_CONTRACTS.include?(contract)
+          name = contract.name.split("::").last
+          raise Ree::Error.new("#{name} is not supported arg validator", :invalid_dsl_usage)
+        end
+
+        return ProcValidator.new(contract) if contract.is_a?(Proc)
+        return ArrayValidator.new(contract) if contract.is_a?(Array)
+        return HashValidator.new(contract) if contract.is_a?(Hash)
+        return RangeValidator.new(contract) if contract.is_a?(Range)
+        return RegexpValidator.new(contract) if contract.is_a?(Regexp)
+        return ValidValidator.new(contract) if contract.respond_to?(:valid?)
+        return ClassValidator.new(contract) if contract.is_a?(Class) || contract.is_a?(Module)
+        
+        DefaultValidator.new(contract)
+      end
+
+      def validators
+        @validators ||= {}
+      end
+    end
+  end
+end

data/lib/ree/contracts.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal  = true
+
+require 'securerandom'
+require 'forwardable'
+require 'delegate'
+
+module Ree::Contracts
+  autoload :ArgContracts, 'ree/contracts/arg_contracts'
+  autoload :ArrayValidator, 'ree/contracts/validators/array_validator'
+  autoload :BadContractError, 'ree/contracts/errors/bad_contract_error'
+  autoload :BaseValidator, 'ree/contracts/validators/base_validator'
+  autoload :CalledArgsValidator, 'ree/contracts/called_args_validator'
+  autoload :ClassValidator, 'ree/contracts/validators/class_validator'
+  autoload :Contractable, 'ree/contracts/contractable'
+  autoload :ContractDefinition, 'ree/contracts/contract_definition'
+  autoload :ContractError, 'ree/contracts/errors/contract_error'
+  autoload :Core, 'ree/contracts/core'
+  autoload :DefaultValidator, 'ree/contracts/validators/default_validator'
+  autoload :Engine, 'ree/contracts/engine'
+  autoload :EngineProxy, 'ree/contracts/engine_proxy'
+  autoload :Error, 'ree/contracts/errors/error'
+  autoload :HashValidator, 'ree/contracts/validators/hash_validator'
+  autoload :MethodDecorator, 'ree/contracts/method_decorator'
+  autoload :ProcValidator, 'ree/contracts/validators/proc_validator'
+  autoload :RangeValidator, 'ree/contracts/validators/range_validator'
+  autoload :RegexpValidator, 'ree/contracts/validators/regexp_validator'
+  autoload :ReturnContractError, 'ree/contracts/errors/return_contract_error'
+  autoload :Truncatable, 'ree/contracts/truncatable'
+  autoload :Utils, 'ree/contracts/utils'
+  autoload :Validators, 'ree/contracts/validators'
+  autoload :ValidValidator, 'ree/contracts/validators/valid_validator'
+
+  def self.no_contracts?
+    ENV["NO_CONTRACTS"]
+  end
+
+  def self.get_method_decorator(target, method_name, scope: :instance)
+    unless scope == :instance || scope == :class
+      raise Ree::Error.new(':scope should be either :class or :instance', :invalid_dsl_usage)
+    end
+
+    decorator_id = MethodDecorator.decorator_id(target, method_name, scope == :class)
+    MethodDecorator.get_decorator(decorator_id)
+  end
+end

data/lib/ree/core/link_validator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal  = true
+
+class Ree::LinkValidator
+  def initialize(packages_facade)
+    @packages_facade = packages_facade
+  end
+  
+  # Validates existance and uniqueness of linked object
+  # @param [Ree::Object] object
+  # @param [Ree::ObjectLink] link
+  # @return [nil]
+  def call(object, link)
+    link_package = @packages_facade.get_package(link.package_name)
+    link_object = link_package.get_object(link.object_name)
+
+    if !link_object
+      msg = <<~DOC
+        object: :#{object.name}
+        path: #{Ree::PathHelper.abs_object_path(object)}
+        error: Unable to find  :#{link.object_name} in :#{link.package_name} package
+      DOC
+
+      raise Ree::Error.new(msg, :invalid_dsl_usage)
+    end
+
+    existing_link = link_object.links.detect do |inj|
+      inj.object_name == link.object_name && inj.package_name == link.package_name
+    end
+
+    if existing_link
+      msg = <<~DOC
+        object: :#{object.name}
+        path: #{Ree::PathHelper.abs_object_path(object)}
+        error: Duplicate link :#{link.object_name}
+      DOC
+
+      raise Ree::Error.new(msg, :invalid_dsl_usage)
+    end
+
+    nil
+  end
+end