ree_lib 1.0.0

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/dsl.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ReeMapper::DSL
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.include(InstanceMethods)
+  end
+
+  def self.extended(base)
+    base.extend(ClassMethods)
+    base.include(InstanceMethods)
+  end
+
+  module InstanceMethods
+    def build
+      self.class.instance_variable_get(:@mapper)
+    end
+  end
+
+  module ClassMethods
+    include Ree::Contracts::Core
+    include Ree::Contracts::ArgContracts
+
+    contract Symbol, Optblock => Ree::Object
+    def mapper(name, &proc)
+      dsl = Ree::ObjectDsl.new(
+        Ree.container.packages_facade, name, self, :object
+      )
+
+      dsl.instance_exec(&proc) if block_given?
+      dsl.factory :build
+
+      Ree.container.compile(dsl.package, name)
+    end
+
+    contract(
+      Kwargs[
+        register_as: Nilor[Symbol]
+      ] => ReeMapper::MapperFactoryProxy
+    )
+    def build_mapper(register_as: nil)
+      mapper_factory = ReeMapper.get_mapper_factory(Object.const_get(name.split('::').first))
+
+      mapper_factory.call(register_as: register_as) do |mapper|
+        self.instance_variable_set(:@mapper, mapper)
+      end
+    end
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/coercion_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ReeMapper::CoercionError < ReeMapper::Error
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ReeMapper::Error < StandardError
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/type_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ReeMapper::TypeError < ReeMapper::Error
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/errors/unsupported_type_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ReeMapper::UnsupportedTypeError < ReeMapper::Error
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/field.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class ReeMapper::Field
+  attr_reader :type, :name, :from, :doc, :optional, :null, :roles, :default,
+              :name_as_str, :name_as_instance_var_name, :from_as_str
+
+  NO_DEFAULT = Object.new.freeze
+
+  contract(
+    Any,
+    Nilor[Symbol],
+    Kwargs[
+      from:     Nilor[Symbol],
+      doc:      Nilor[String],
+      optional: Bool,
+      null:     Bool,
+      role:     Nilor[ArrayOf[Symbol], Symbol],
+      default:  Any
+    ] => Any
+  ).throws(ArgumentError)
+  def initialize(type, name = nil, from: nil, doc: nil, optional: false, null: false, role: nil, default: NO_DEFAULT)
+    @type     = type
+    @name     = name
+    @from     = from || name
+    @doc      = doc
+    @optional = optional
+    @null     = null
+    @roles    = Array(role)
+    @default  = default
+
+    @name_as_str               = @name.to_s
+    @name_as_instance_var_name = :"@#{@name}"
+    @from_as_str               = @from.to_s
+
+    raise ArgumentError, 'required fields do not support defaults' if has_default? && !optional
+  end
+
+  contract None => Bool
+  def has_default?
+    default != NO_DEFAULT
+  end
+
+  contract Nilor[Symbol, ArrayOf[Symbol]] => Bool
+  def has_role?(role)
+    return true  if roles.empty?
+    return false if role.nil?
+
+    if role.is_a?(Array)
+      role.any? { roles.include?(_1) }
+    else
+      roles.include?(role)
+    end
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/functions/build_mapper_factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class ReeMapper::BuildMapperFactory
+  include Ree::FnDSL
+
+  fn :build_mapper_factory do
+    link 'ree_mapper/mapper', -> { Mapper }
+    link 'ree_mapper/mapper_factory', -> { MapperFactory }
+    link 'ree_mapper/mapper_strategy', -> { MapperStrategy }
+  end
+
+  contract(ArrayOf[MapperStrategy] => SubclassOf[MapperFactory])
+  def call(strategies:)
+    klass = Class.new(ReeMapper::MapperFactory)
+
+    klass.instance_eval {
+      @types = {}
+      @strategies = strategies
+    }
+
+    klass.register(:bool, Mapper.build(strategies, ReeMapper::Bool.new))
+    klass.register(:date_time, Mapper.build(strategies, ReeMapper::DateTime.new))
+    klass.register(:time, Mapper.build(strategies, ReeMapper::Time.new))
+    klass.register(:date, Mapper.build(strategies, ReeMapper::Date.new))
+    klass.register(:float, Mapper.build(strategies, ReeMapper::Float.new))
+    klass.register(:integer, Mapper.build(strategies, ReeMapper::Integer.new))
+    klass.register(:string, Mapper.build(strategies, ReeMapper::String.new))
+
+    klass
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/functions/build_mapper_strategy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class ReeMapper::BuildMapperStrategy
+  include Ree::FnDSL
+
+  fn :build_mapper_strategy
+
+  OUTPUT_MAP = {
+    string_key_hash: ReeMapper::StringKeyHashOutput,
+    symbol_key_hash: ReeMapper::SymbolKeyHashOutput,
+    object:          ReeMapper::ObjectOutput
+  }.freeze
+
+  contract(Kwargs[
+    method:          Symbol,
+    output:          Symbol,
+    always_optional: Bool
+  ] => ReeMapper::MapperStrategy).throws(ArgumentError)
+  def call(method:, output:, always_optional: false)
+    raise ArgumentError, 'invalid output' unless OUTPUT_MAP.key?(output)
+
+    ReeMapper::MapperStrategy.new(
+      method:          method,
+      output:          OUTPUT_MAP.fetch(output).new,
+      always_optional: always_optional
+    )
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class ReeMapper::Mapper
+  contract(ArrayOf[ReeMapper::MapperStrategy], Nilor[ReeMapper::AbstractType] => Any)
+  def self.build(strategies, type = nil)
+    if type
+      strategies.each do |strategy|
+        method = strategy.method
+        next if type.respond_to?(method)
+        raise ReeMapper::UnsupportedTypeError, "type #{type.name} should implement method `#{method}`"
+      end
+    end
+
+    klass = Class.new(self)
+
+    klass.instance_eval do
+      strategies.each do |strategy|
+        method = strategy.method
+
+        if type
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def #{method}(obj, role: nil)
+              @type.#{method}(obj, role: role)
+            end
+          RUBY
+        else
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def #{method}(obj, role: nil)
+              @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
+                next unless field.has_role?(role)
+
+                if @#{method}_strategy.has_value?(obj, field)
+                  value = @#{method}_strategy.get_value(obj, field)
+                  unless value.nil? && field.null
+                    value = field.type.public_send(:#{method}, value, role: role)
+                  end
+                  @#{method}_strategy.assign_value(acc, field, value)
+                elsif field.optional || @#{method}_strategy.always_optional
+                  if field.has_default?
+                    value = field.default
+                    unless value.nil? && field.null
+                      value = field.type.public_send(:#{method}, value, role: role)
+                    end
+                    @#{method}_strategy.assign_value(acc, field, value)
+                  end
+                else
+                  raise ReeMapper::TypeError, "Missing required field `\#{field.from}`"
+                end
+              end
+            end
+          RUBY
+        end
+      end
+    end
+
+    klass.new(strategies, type)
+  end
+
+  attr_reader :strategies, :strategy_methods, :fields, :type
+
+  def initialize(strategies, type)
+    @fields = {}
+    @type = type
+    @strategies = strategies
+    @strategy_methods = strategies.map(&:method)
+
+    strategies.each do |strategy|
+      method = strategy.method
+      instance_variable_set(:"@#{method}_strategy", strategy)
+    end
+  end
+
+  contract(Any, Symbol, Ksplat[RestKeys => Any] => nil)
+  def add_field(type, name, **opts)
+    @fields[name] = ReeMapper::Field.new(type, name, **opts)
+    nil
+  end
+
+  contract(None => Nilor[Symbol])
+  def name
+    @name
+  end
+
+  contract(Symbol => Symbol)
+  def name=(name)
+    @name = name
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper_factory.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+class ReeMapper::MapperFactory
+  class << self
+    attr_reader :types, :strategies
+  end
+
+  HASH_KEY_OPTION_VALUES = [:symbol, :string, nil].freeze
+  HASH_KEY_OPTION_MAP = {
+    symbol: ReeMapper::SymbolKeyHashOutput,
+    string: ReeMapper::StringKeyHashOutput
+  }.freeze
+
+  contract(Symbol, Any => Class).throws(ArgumentError)
+  def self.register(name, type)
+    raise ArgumentError, "name of mapper type should not include `?`" if name.to_s.end_with?('?')
+    raise ArgumentError, "type :#{name} already registered" if types.key?(name)
+    raise ArgumentError, "method :#{name} already defined" if method_defined?(name)
+
+    type = type.dup
+    type.name = name
+    type.freeze
+    types[name] = type
+
+    class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+      def #{name}(field_name = nil, optional: false, **opts)
+        raise ReeMapper::Error, "invalid DSL usage" unless @mapper
+        raise ArgumentError, "array item can't be optional" if field_name.nil? && optional
+
+        type = self.class.types.fetch(:#{name})
+
+        @mapper.strategy_methods.each do |method|
+          next if type.respond_to?(method)
+          raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement method `\#{method}`"
+        end
+
+        return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name
+
+        @mapper.add_field(type, field_name, optional: optional, **opts)
+      end
+
+      def #{name}?(field_name, **opts)
+        #{name}(field_name, optional: true, **opts)
+      end
+    RUBY
+
+    self
+  end
+
+  contract(
+    Kwargs[
+      register_as: Nilor[Symbol]
+    ],
+    Optblock => ReeMapper::MapperFactoryProxy).throws(ArgumentError
+  )
+  def self.call(register_as: nil, &blk)
+    ReeMapper::MapperFactoryProxy.new(self, register_as: register_as, &blk)
+  end
+
+  contract(ReeMapper::Mapper => Any)
+  def initialize(mapper)
+    @mapper = mapper
+  end
+
+  contract(Nilor[Symbol], Kwargs[each: Nilor[ReeMapper::Field], optional: Bool, key: Nilor[Symbol]], Ksplat[RestKeys => Any], Optblock => Nilor[ReeMapper::Field])
+  def array(field_name = nil, each: nil, optional: false, key: nil, **opts, &blk)
+    raise ReeMapper::Error, "invalid DSL usage" unless @mapper
+    raise ArgumentError, "array item can't be optional" if field_name.nil? && optional
+    raise ArgumentError, 'array type should use either :each or :block' if each && blk || !each && !blk
+    raise ArgumentError, 'invalid :key option value' unless HASH_KEY_OPTION_VALUES.include?(key)
+
+    if blk
+      each = ReeMapper::Field.new(
+        hash_from_blk(key: key, &blk)
+      )
+    end
+
+    type = ReeMapper::Mapper.build(@mapper.strategies, ReeMapper::Array.new(each))
+
+    return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name
+
+    @mapper.add_field(type, field_name, optional: optional, **opts)
+  end
+
+  contract(Symbol, Any, Ksplat[RestKeys => Any] => Nilor[ReeMapper::Field])
+  def array?(field_name, each:, **opts)
+    raise ArgumentError if opts.key?(:optional)
+
+    array(field_name, each: each, optional: true, **opts)
+  end
+
+  contract(Symbol, Kwargs[key: Nilor[Symbol]], Ksplat[RestKeys => Any], Block => nil)
+  def hash(field_name, key: nil, **opts, &blk)
+    raise ReeMapper::Error, "invalid DSL usage" unless @mapper
+    raise ArgumentError, 'invalid :key option value' unless HASH_KEY_OPTION_VALUES.include?(key)
+
+    type = hash_from_blk(key: key, &blk)
+
+    @mapper.add_field(type, field_name, **opts)
+  end
+
+  contract(Symbol, Ksplat[RestKeys => Any], Block => nil)
+  def hash?(field_name, **opts, &blk)
+    hash(field_name, optional: true, **opts, &blk)
+  end
+
+  private
+
+  def hash_from_blk(key:, &blk)
+    mapper_proxy = self.class.call
+
+    strategies = @mapper.strategies.map do |strategy|
+      strategy = strategy.dup
+      output = strategy.output
+      if key
+        strategy.output = HASH_KEY_OPTION_MAP.fetch(key).new
+      elsif !(output.is_a?(ReeMapper::SymbolKeyHashOutput) || output.is_a?(ReeMapper::StringKeyHashOutput))
+        strategy.output = ReeMapper::SymbolKeyHashOutput.new
+      end
+      strategy
+    end
+
+    strategies[0..-2].each do |strategy|
+      mapper_proxy.use(strategy)
+    end
+
+    _hsh_mapper = mapper_proxy.use(strategies.last, &blk)
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper_factory_proxy.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class ReeMapper::MapperFactoryProxy
+  attr_reader :mapper_factory, :register_as, :strategies, :after_build
+
+  contract(
+    Class, # SubclassOf[ReeMapper::MapperFactory],
+    Kwargs[
+      register_as: Nilor[Symbol]
+    ],
+    Optblock => Any
+  )
+  def initialize(mapper_factory, register_as:, &blk)
+    @mapper_factory = mapper_factory
+    @register_as    = register_as
+    @strategies     = []
+    @after_build    = blk
+  end
+
+  contract(Or[Symbol, ReeMapper::MapperStrategy], Kwargs[dto: Nilor[Class]], Optblock => Or[ReeMapper::MapperFactoryProxy, ReeMapper::Mapper]).throws(ArgumentError)
+  def use(strategy_or_method, dto: nil, &blk)
+    if strategy_or_method.is_a?(ReeMapper::MapperStrategy)
+      strategy = strategy_or_method
+    else
+      strategy = mapper_factory.strategies.detect { _1.method == strategy_or_method }
+      raise ArgumentError, "MapperFactory strategy :#{strategy_or_method} not found" unless strategy
+      strategy = Marshal.load(Marshal.dump(strategy))
+      strategy.dto = dto if dto
+    end
+
+    self.strategies << strategy
+
+    return self unless blk
+
+    mapper = ReeMapper::Mapper.build(strategies)
+    mapper_factory.new(mapper).instance_exec(&blk)
+
+    mapper_factory.register(register_as, mapper) if register_as
+
+    after_build&.call(mapper)
+
+    mapper
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper_strategy.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class ReeMapper::MapperStrategy
+  attr_reader :method, :always_optional
+
+  contract(Symbol, ReeMapper::StrategyOutput, Bool => Any)
+  def initialize(method:, output:, always_optional:)
+    @method          = method
+    @output          = output
+    @always_optional = always_optional
+  end
+
+  contract None => ReeMapper::StrategyOutput
+  def output
+    @output
+  end
+
+  contract ReeMapper::StrategyOutput => ReeMapper::StrategyOutput
+  def output=(output)
+    @output = output
+  end
+
+  contract(Any)
+  def build_object
+    output.build_object
+  end
+
+  contract(Any, ReeMapper::Field, Any => nil)
+  def assign_value(object, field, value)
+    output.assign_value(object, field, value)
+  end
+
+  contract(Any, ReeMapper::Field => Bool)
+  def has_value?(obj, field)
+    if obj.is_a?(Hash)
+      obj.key?(field.from) || obj.key?(field.from_as_str)
+    else
+      obj.respond_to?(field.from)
+    end
+  end
+
+  contract(Any, ReeMapper::Field => Any)
+  def get_value(obj, field)
+    if obj.is_a?(Hash)
+      obj.key?(field.from) ? obj[field.from] : obj[field.from_as_str]
+    else
+      obj.public_send(field.from)
+    end
+  end
+
+  contract(Class => Class)
+  def dto=(dto)
+    output.dto = dto
+  end
+
+  contract(None => Nilor[Class])
+  def dto
+    output.dto
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/object_output.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ReeMapper::ObjectOutput < ReeMapper::StrategyOutput
+  def initialize(*)
+    @dto = Object
+    super
+  end
+
+  contract(Object)
+  def build_object
+    @dto.allocate
+  end
+
+  contract(Object, ReeMapper::Field, Any => nil)
+  def assign_value(object, field, value)
+    object.instance_variable_set(field.name_as_instance_var_name, value)
+    nil
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/strategy_output.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class ReeMapper::StrategyOutput
+  def build_object
+    raise NotImplementedError
+  end
+
+  def assign_value(*)
+    raise NotImplementedError
+  end
+
+  contract(Class => Class)
+  def dto=(dto)
+    @dto = dto
+  end
+
+  contract(None => Nilor[Class])
+  def dto
+    @dto
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/string_key_hash_output.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class ReeMapper::StringKeyHashOutput < ReeMapper::StrategyOutput
+  contract(Hash)
+  def build_object
+    Hash.new
+  end
+
+  contract(Object, ReeMapper::Field, Any => nil)
+  def assign_value(object, field, value)
+    object[field.name_as_str] = value
+    nil
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/strategy_outputs/symbol_key_hash_output.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class ReeMapper::SymbolKeyHashOutput < ReeMapper::StrategyOutput
+  contract(Hash)
+  def build_object
+    Hash.new
+  end
+
+  contract(Object, ReeMapper::Field, Any => nil)
+  def assign_value(object, field, value)
+    object[field.name] = value
+    nil
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/abstract_type.rb

@@ -0,0 +1,17 @@
+class ReeMapper::AbstractType
+  def serialize(value, role: nil)
+    raise NotImplementedError
+  end
+
+  def cast(value, role: nil)
+    raise NotImplementedError
+  end
+
+  def db_dump(value, role: nil)
+    raise NotImplementedError
+  end
+
+  def db_load(value, role: nil)
+    raise NotImplementedError
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/array.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class ReeMapper::Array < ReeMapper::AbstractType
+  attr_reader :of
+
+  contract ReeMapper::Field => Any
+  def initialize(of)
+    @of = of
+  end
+
+  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def serialize(value, role: nil)
+    if value.is_a?(Array)
+      value.map {
+        if _1.nil? && of.null
+          _1
+        else
+          of.type.serialize(_1, role: role)
+        end
+      }
+    else
+      raise ReeMapper::TypeError, 'should be an array'
+    end
+  end
+
+  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def cast(value, role: nil)
+    if value.is_a?(Array)
+      value.map {
+        if _1.nil? && of.null
+          _1
+        else
+          of.type.cast(_1, role: role)
+        end
+      }
+    else
+      raise ReeMapper::TypeError, "should be an array"
+    end
+  end
+
+  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def db_dump(value, role: nil)
+    if value.is_a?(Array)
+      value.map {
+        if _1.nil? && of.null
+          _1
+        else
+          of.type.db_dump(_1, role: role)
+        end
+      }
+    else
+      raise ReeMapper::TypeError, 'should be an array'
+    end
+  end
+
+  contract(Any, Kwargs[role: Nilor[Symbol, ArrayOf[Symbol]]] => Array).throws(ReeMapper::TypeError)
+  def db_load(value, role: nil)
+    if value.is_a?(Array)
+      value.map {
+        if _1.nil? && of.null
+          _1
+        else
+          of.type.db_load(_1, role: role)
+        end
+      }
+    else
+      raise ReeMapper::TypeError, "should be an array"
+    end
+  end
+end