ree 1.0.0

data/lib/ree/container.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal  = true
+
+require 'pathname'
+
+class Ree::Container
+  class << self
+    SEMAPHORE = Mutex.new
+    private_constant :SEMAPHORE
+
+    # singleton
+    def instance
+      SEMAPHORE.synchronize do
+        @instance ||= begin
+          self.new
+        end
+      end
+
+      @instance
+    end
+  end
+
+  include Ree::Args
+
+  MOUNT_AS = [:fn, :object]
+
+  attr_reader :packages_facade
+
+  def initialize
+    @packages_facade = Ree::PackagesFacade.new
+    @object_compiler = Ree::ObjectCompiler.new(@packages_facade)
+  end
+
+  # @param [Ree::Package] package
+  # @param [Symbol] object_name
+  def compile(package, object_name)
+    compile_object("#{package.name}/#{object_name}")
+  end
+
+  # @param [String] name_with_package
+  # @return [Ree::Object]
+  def compile_object(name_with_package)
+    check_arg(name_with_package, :name_with_package, String)
+
+    list = name_with_package.to_s.split('/')
+
+    name = nil
+    package_name = nil
+
+    if list.size == 2
+      package_name = list.first.to_sym
+      name = list.last.to_sym
+    else
+      raise Ree::Error.new("'package/name' definition should be used to load object", :invalid_dsl_usage)
+    end
+
+    @packages_facade.get_loaded_package(package_name)
+    @packages_facade.load_package_object(package_name, name)
+    
+    @object_compiler.call(package_name, name)
+  end
+
+  # @param [Symbol] package_name
+  # @return [Ree::Package]
+  def load_package(package_name)
+    @packages_facade.load_entire_package(package_name)
+  end
+end

data/lib/ree/contracts/arg_contracts/any.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Any
+      def self.valid?(value)
+        true
+      end
+
+      def self.to_s
+        "Any"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/array_of.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class ArrayOf
+      extend Ree::Contracts::ArgContracts::Squarable
+      include Ree::Contracts::Truncatable
+
+      attr_reader :validator
+      
+      def initialize(*contracts)
+        if contracts.size != 1
+          raise BadContractError, 'ArrayOf should accept exactly one contract'
+        end
+
+        @validator = Validators.fetch_for(contracts.first)
+      end
+
+      def valid?(value)
+        value.is_a?(Array) &&
+          value.all?(&validator.method(:call))
+      end
+
+      def to_s
+        "ArrayOf[#{validator.to_s}]"
+      end
+
+      def message(value, name, lvl = 1)
+        unless value.is_a?(Array)
+          return "expected Array, got #{value.class} => #{truncate(value.inspect)}"
+        end
+
+        errors = []
+        sps = "  " * lvl
+
+        value.each_with_index do |val, 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
+end

data/lib/ree/contracts/arg_contracts/block.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Block
+      def self.valid?(*)
+        raise BadContractError, "#{name} contract is not allowed to use as argument contract"
+      end
+
+      def to_s
+        "Block"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/bool.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Bool
+      extend Ree::Contracts::Truncatable
+
+      def self.valid?(value)
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+
+      def self.message(value, name, lvl = 1)
+        "expected Bool, got #{value.class} => #{truncate(value.inspect)}"
+      end
+
+      def self.to_s
+        "Bool"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/eq.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Eq
+      extend Ree::Contracts::ArgContracts::Squarable
+      include Ree::Contracts::Truncatable
+
+      attr_reader :contract
+      
+      def initialize(contract)
+        @contract = contract
+      end
+
+      def valid?(value)
+        value.equal?(contract)
+      end
+
+      def to_s
+        "Eq[#{contract.inspect}]"
+      end
+
+      def message(value, name, lvl = 1)
+        "expected #{truncate(self.to_s, 30)}, got #{truncate(value.inspect)}"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/exactly.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Exactly
+      extend Ree::Contracts::ArgContracts::Squarable
+      include Ree::Contracts::Truncatable
+
+      attr_reader :klass
+      
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def valid?(value)
+        value.class == klass
+      end
+
+      def to_s
+        "Exactly[#{klass.inspect}]"
+      end
+
+      def message(value, name, lvl = 1)
+        "expected #{truncate(self.to_s, 30)}, got #{truncate(value.class.inspect)}"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/hash_of.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class HashOf
+      extend Ree::Contracts::ArgContracts::Squarable
+      include Ree::Contracts::Truncatable
+
+      attr_reader :key_validator, :value_validator
+      
+      def initialize(*contracts)
+        if contracts.size != 2
+          raise BadContractError, 'HashOf should accept exactly two contracts'
+        end
+
+        @key_validator   = Validators.fetch_for(contracts[0])
+        @value_validator = Validators.fetch_for(contracts[1])
+      end
+
+      def valid?(value)
+        value.is_a?(Hash) &&
+          value.each_key.all?(&key_validator.method(:call)) &&
+          value.each_value.all?(&value_validator.method(:call))
+      end
+
+      def to_s
+        "HashOf[#{key_validator.to_s}, #{value_validator.to_s}]"
+      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
+
+        value.each do |key, val|
+          if errors.size > 4
+            errors << "\n\t#{sps} - ..."
+            break
+          end
+
+          unless key_validator.call(key)
+            msg = key_validator.message(key, "#{name}[#{key.inspect}]", lvl + 1)
+            errors << "\n\t#{sps} - invalid key #{key.inspect}, #{msg}"
+          end
+
+          unless value_validator.call(val)
+            msg = key_validator.message(val, "#{name}[#{key.inspect}]", lvl + 1)
+            errors << "\n\t#{sps} - invalid value for #{key.inspect} key, #{msg}"
+          end
+        end
+
+        errors.join
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/ksplat.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ree::Contracts
+  module ArgContracts
+    class RestKeys; end
+
+    class Ksplat
+      include Ree::Contracts::Truncatable
+
+      attr_reader :validators, :rest_validator
+      
+      def self.[](**contracts)
+        if contracts.empty?
+          raise BadContractError, 'Ksplat contract should accept at least one contract'
+        end
+
+        new(**contracts)
+      end
+
+      def initialize(**contracts)
+        @contracts = contracts
+        @opt_dict = Set.new
+
+        @validators = contracts
+          .transform_values { Validators.fetch_for(_1) }
+          .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
+          }
+        
+        @rest_validator = @validators[RestKeys]
+        
+        if @rest_validator
+          @validators.default = @rest_validator
+        end
+      end
+
+      def valid?(value)
+        return false unless value.is_a?(Hash)
+        return false if value.has_key?(RestKeys)
+        
+        is_valid = value.all? do |key, v|
+          if @validators.has_key?(key)
+            @validators[key].call(v)
+          elsif @rest_validator
+            @rest_validator.call(v)
+          else
+            false
+          end
+        end
+
+        return false if !is_valid
+
+        return false if @validators.detect do |key, validator|
+          next if key == RestKeys || optional?(key)
+          next if value.has_key?(key)
+          true
+        end
+
+        true
+      end
+
+      def to_s
+        "Ksplat[#{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
+
+        if value.has_key?(RestKeys)
+          return "RestKeys is a reserved key for Ksplat contract"
+        end
+  
+        errors = []
+        sps = "  " * lvl
+        all_keys = (@validators.keys - [RestKeys] + value.keys).uniq
+
+        all_keys.each do |key|
+          validator = @validators[key]
+
+          if !validator
+            errors << "\n\t#{sps} - #{name}[#{key.inspect}]: unexpected"
+            next
+          end
+
+          if !value.has_key?(key)
+            if !optional?(key)
+              errors << "\n\t#{sps} - #{name}[#{key.inspect}]: missing"
+            else
+              next
+            end
+          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}"
+
+          if errors.size > 3
+            errors << "\n\t#{sps} - ..."
+            break
+          end
+        end
+  
+        errors.join
+      end
+
+      private
+
+      def key_to_s(key)
+        k = if optional?(key)
+          v = "#{key}?"
+          key.is_a?(String) ? v : v.to_sym
+        elsif key == RestKeys
+          'RestKeys'
+        else
+          key.to_s
+        end
+  
+        k.inspect
+      end
+
+      def optional?(key)
+        @opt_dict.include?(key)
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/kwargs.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Kwargs < SimpleDelegator
+      def self.[](**contracts)
+        if contracts.empty?
+          raise BadContractError, 'Kwargs contract should accept at least one contract'
+        end
+
+        new(**contracts)
+      end
+
+      attr_reader :contracts
+      
+      def initialize(**contracts)
+        @contracts = contracts
+        super(contracts)
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/nilor.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Nilor < Or
+      def initialize(*)
+        super
+        validators << Validators.fetch_for(nil)
+      end
+
+      def to_s
+        "Nilor[#{validators[0..-2].map(&:to_s).join(', ')}]"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/none.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class None
+      def self.valid?(*)
+        raise BadContractError, "None contract is not allowed to use as argument contract"
+      end
+
+      def self.to_s
+        "None"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/optblock.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Optblock < Block
+      def to_s
+        "Optblock"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/or.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class Or
+      extend Ree::Contracts::ArgContracts::Squarable
+      include Ree::Contracts::Truncatable
+
+      attr_reader :validators
+
+      def initialize(*contracts)
+        @validators = contracts.map(&Validators.method(:fetch_for))
+      end
+
+      def to_s
+        "Or[#{validators.map(&:to_s).join(', ')}]"
+      end
+
+      def valid?(value)
+        validators.any? do |validator|
+          validator.call(value)
+        end
+      end
+
+      def message(value, name, lvl = 1)
+        "expected #{truncate(self.to_s, 30)}, got #{truncate(value.inspect)}"
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/range_of.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ree::Contracts
+  module ArgContracts
+    class RangeOf
+      extend Ree::Contracts::ArgContracts::Squarable
+      include Ree::Contracts::Truncatable
+
+      attr_reader :validator
+      
+      def initialize(*contracts)
+        if contracts.size != 1
+          raise BadContractError, 'RangeOf should accept exactly one contract'
+        end
+
+        @validator = Validators.fetch_for(contracts.first)
+      end
+
+      def valid?(value)
+        value.is_a?(Range) &&
+          validator.call(value.begin) &&
+          validator.call(value.end)
+      end
+
+      def to_s
+        "RangeOf[#{validator.to_s}]"
+      end
+
+      def message(value, name, lvl = 1)
+        unless value.is_a?(Range)
+          return "expected Range, got #{value.class} => #{truncate(value.inspect)}"
+        end
+
+        errors = []
+        sps = "  " * lvl
+
+        unless validator.call(value.begin)
+          msg = validator.message(value.begin, "#{name}.begin", lvl + 1)
+          errors << "\n\t#{sps} - #{name}.begin: #{msg}"
+        end
+
+        unless validator.call(value.end)
+          msg = validator.message(value.end, "#{name}.end", lvl + 1)
+          errors << "\n\t#{sps} - #{name}.end: #{msg}"
+        end
+
+        errors.join
+      end
+    end
+  end
+end

data/lib/ree/contracts/arg_contracts/set_of.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ree::Contracts
+  module ArgContracts
+    class SetOf
+      extend Ree::Contracts::ArgContracts::Squarable
+      include Ree::Contracts::Truncatable
+
+      attr_reader :validator
+      
+      def initialize(*contracts)
+        if contracts.size != 1
+          raise BadContractError, 'SetOf should accept exactly one contract'
+        end
+
+        @validator = Validators.fetch_for(contracts.first)
+      end
+
+      def valid?(value)
+        value.is_a?(Set) &&
+          value.all?(&validator.method(:call))
+      end
+
+      def to_s
+        "SetOf[#{validator.to_s}]"
+      end
+
+      def message(value, name, lvl = 1)
+        unless value.is_a?(Set)
+          return "expected Set, got #{value.class} => #{truncate(value.inspect)}"
+        end
+
+        errors = []
+        sps = "  " * lvl
+
+        value.each_with_index do |val, 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
+end