ree_lib 1.0.69 → 1.0.71

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c746828c8b09f58c0406659649ef01ba7b7300f4b1f35f808f8e1f58a0dc4165
-  data.tar.gz: c03ddd00be42dbbe2ee2e2660a105a84912d19ccb5251fd882bd88d04e5bd781
+  metadata.gz: 83750e368c52ed97daa01d069e57a184129c6bafb7bd7867aa8c71685562da16
+  data.tar.gz: 37ea4a0f4c852bed89692d47f5c86891f281a16f1e13f04faeb2670f57bfd173
 SHA512:
-  metadata.gz: 5fa6ca950b18d4e6678610f8dd1b1d3c239090e18d7c914be33643e75d846332e041109d8cb2f6d301398e9eafeeb6897320bfac688c2defb427bc2bec6a4e5c
-  data.tar.gz: 13405b30d0b4be4aba5e579f8bab5a410af29fe820a5aca37502ea6a7d356a5d5fdad315214fa70b8581927c7ee712607a101b191ec2d9fd383a4b4e1989f8a8
+  metadata.gz: ff00e69c9a2b54dd03eee000076e3aac5cb0236b53cdbba0ed669eba2d5918d1c14d88f0c8a6d8e58497a86e02208a0f5850fbef294e552ad2f994aaa83cf89c
+  data.tar.gz: bb9a5580e423c17d894d07a69896f39d0d26ef9fc21b8bd3871c505034516a20fa2c5bf6a95827a1733a4cb06a6e6fea7bb4dd0a0e4735f13eca1fb5f2087cb9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.69)
+    ree_lib (1.0.71)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)

data/lib/ree_lib/packages/ree_dao/package/ree_dao/associations.rb

@@ -93,7 +93,7 @@ module ReeDao
         association = Association.new(self, parent_dao, list, **global_opts)
 
         if assoc_type == :field
-          association.handle_field(assoc_name, __opts)
+          association.handle_field(__opts)
         else
           association.load(assoc_type, assoc_name, **get_assoc_opts(__opts), &block)
         end

data/lib/ree_lib/packages/ree_dao/package/ree_dao/wrappers/pg_jsonb.rb

@@ -48,7 +48,8 @@ class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
       Float,
       String,
       Bool,
-      NilClass
+      NilClass,
+      Rational,
     ]
   ).throws(ReeMapper::TypeError)
   def db_load(value, name:, role: nil, fields_filters: [])

data/lib/ree_lib/packages/ree_dao/package/ree_dao.rb

@@ -26,3 +26,11 @@ module ReeDao
     ENV.has_key?("REE_DAO_SYNC_ASSOCIATIONS") && ENV["REE_DAO_SYNC_ASSOCIATIONS"] == "true"
   end
 end
+
+# ReeEnum::Value#sql_literal is used to properly serialize enum values
+# for database queries
+class ReeEnum::Value
+  def sql_literal(*)
+    mapped_value.to_s
+  end
+end

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/functions/load_agg/agg_spec.rb

@@ -130,8 +130,7 @@ RSpec.describe :agg do
     end
 
     def some_method(list)
-      # puts list.map(&:id)
-      # puts list.map { _1.class.name }
+      list.each { _1.some_field = :some_value if _1.respond_to?(:some_field=) }
     end
 
     def passport_opts
@@ -978,4 +977,20 @@ RSpec.describe :agg do
     res = agg(users, users.where(organization_id: organization.id))
     expect(res.count).to eq(2)
   }
+
+  context "when sync mode enabled" do
+    it {
+      organization = ReeDaoAggTest::Organization.new(name: "Test Org")
+      organizations.put(organization)
+      user = ReeDaoAggTest::User.new(name: "John", age: 33, organization_id: organization.id)
+      users.put(user)
+
+      allow(user).to receive(:some_field=)
+      expect(user).to receive(:some_field=).with(:some_value)
+
+      ENV['REE_DAO_SYNC_ASSOCIATIONS'] = "true"
+      res = agg_users.([user])
+      ENV.delete('REE_DAO_SYNC_ASSOCIATIONS')
+    }
+  end
 end

data/lib/ree_lib/packages/ree_dao/spec/ree_dao/wrappers/pg_jsonb_spec.rb

@@ -29,6 +29,7 @@ RSpec.describe 'ReeDao::PgJsonb' do
       pg_jsonb? :number, integer
       pg_jsonb? :boolean, bool
       pg_jsonb? :any, any
+      pg_jsonb? :rational, rational
     end
   }
 
@@ -39,13 +40,15 @@ RSpec.describe 'ReeDao::PgJsonb' do
         numbers: [1, 2],
         figures: [{ coords: 'x=1,y=1' }],
         number: 1,
-        boolean: true
+        boolean: true,
+        rational: Rational("1/3"),
       })).to eq({
         payload: { key: 'key' },
         numbers: [1, 2],
         figures: [{ coords: 'x=1,y=1' }],
         number: 1,
-        boolean: true
+        boolean: true,
+        rational: "1/3",
       })
     }
 
@@ -69,13 +72,15 @@ RSpec.describe 'ReeDao::PgJsonb' do
         numbers: Sequel::Postgres::JSONBArray.new([1, 2]),
         figures: Sequel::Postgres::JSONBArray.new([{ coords: 'x=1,y=1' }]),
         number: 1,
-        boolean: true
+        boolean: true,
+        rational: "1/3"
       })).to eq({
         payload: { key: 'key' },
         numbers: [1, 2],
         figures: [{ coords: 'x=1,y=1' }],
         number: 1,
-        boolean: true
+        boolean: true,
+        rational: Rational("1/3"),
       })
     }
 

data/lib/ree_lib/packages/ree_enum/package/ree_enum/contractable.rb

@@ -4,10 +4,10 @@ module ReeEnum::Contractable
   include Ree::Contracts::Truncatable
 
   def valid?(value)
-    value.is_a?(ReeEnum::Value) && value.enum_name == self.enum_name && all.include?(value)
+    value.is_a?(ReeEnum::Value) && value.enum_name == get_enum_name && get_values.each.include?(value)
   end
 
   def message(value, name, lvl = 1)
-    return "expected one of #{self.name}, got #{value.class} => #{truncate(value.inspect)}"
+    "expected one of #{self.name}, got #{value.class} => #{truncate(value.inspect)}"
   end
 end

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

@@ -52,28 +52,17 @@ module ReeEnum
               ] => ReeEnum::Value
             ).throws(ReeMapper::CoercionError)
             def cast(value, name:, role: nil)
-              if value.is_a?(String)
-                enum_val = @enum.values.all.detect { |v| v.to_s == value }
-
-                if !enum_val
-                  raise ReeMapper::CoercionError, "`#{name}` should be one of #{@enum.values.all.map(&:to_s).inspect}"
-                end
-
-                enum_val
-              elsif value.is_a?(Integer)
-                enum_val = @enum.values.all.detect { |v| v.to_i == value }
-
-                if !enum_val
-                  raise ReeMapper::CoercionError, "`#{name}` should be one of #{@enum.values.all.map(&:to_s).inspect}"
-                end
-
-                enum_val
-              else
-                enum_val = @enum.values.all.detect { |v| v == value }
-                return enum_val if enum_val
+              enum_value = if value.is_a?(String)
+                @enum.get_values.by_value(value)
+              elsif value.is_a?(ReeEnum::Value)
+                @enum.get_values.each.find { _1 == value }
+              end
 
-                raise ReeMapper::CoercionError, "`#{name}` should be one of #{@enum.values.all.map(&:to_s).inspect}"
+              if enum_value.nil?
+                raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}"
               end
+
+              enum_value
             end
 
             contract(
@@ -81,21 +70,38 @@ module ReeEnum
               Kwargs[
                 name: String,
                 role: Nilor[Symbol, ArrayOf[Symbol]]
-              ] => Integer
+              ] => Or[Integer, String]
             )
             def db_dump(value, name:, role: nil)
-              value.to_i
+              value.mapped_value
             end
 
             contract(
-              Integer,
+              Or[Integer, String],
               Kwargs[
                 name: String,
                 role: Nilor[Symbol, ArrayOf[Symbol]]
               ] => ReeEnum::Value
-            ).throws(ReeMapper::TypeError)
+            ).throws(ReeMapper::CoercionError)
             def db_load(value, name:, role: nil)
-              cast(value, name: name, role: role)
+              enum_val = @enum.get_values.by_mapped_value(value)
+
+              if !enum_val
+                raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}"
+              end
+
+              enum_val
+            end
+
+            private
+
+            def enum_inspection
+              @enum_inspect ||= truncate(@enum.get_values.each.map(&:to_s).inspect)
+            end
+
+            def truncate(str, limit = 180)
+              return str if str.length <= limit
+              "#{str[0..limit]}..."
             end
           end
 
@@ -113,7 +119,7 @@ module ReeEnum
             ->(*) {
               {
                 type: 'string',
-                enum: values.all.map(&:to_s)
+                enum: get_values.each.map(&:to_s)
               }
             }
           )
@@ -128,7 +134,7 @@ module ReeEnum
         )
 
         mapper_factory.register_type(
-          self.enum_name, type_for_mapper
+          self.get_enum_name, type_for_mapper
         )
       end
     end

data/lib/ree_lib/packages/ree_enum/package/ree_enum/enumerable.rb

@@ -5,20 +5,6 @@ require_relative 'values'
 require_relative 'contractable'
 
 module ReeEnum::Enumerable
-  module CommonMethods
-    def by_value(value)
-      values.by_value(value)
-    end
-
-    def by_number(number)
-      values.by_number(number)
-    end
-
-    def all
-      values.all
-    end
-  end
-
   def self.included(base)
     base.extend(ClassMethods)
   end
@@ -26,43 +12,45 @@ module ReeEnum::Enumerable
   module ClassMethods
     include ReeEnum::Contractable
 
+    RESTRICTED_METHODS = [
+      :setup_enum, :get_values, :get_enum_name,
+      :val, :self, :class, :alias
+    ].freeze
+
     def setup_enum(enum_name)
       @values ||= ReeEnum::Values.new(self, enum_name)
     end
 
-    def values
+    def get_values
       @values
     end
 
-    def enum_name
-      return if !@values
-      @values.enum_name
+    def get_enum_name
+      @values&.enum_name
     end
 
-    include CommonMethods
+    def val(value, mapped_value = value.to_s, method: value.to_sym)
+      value = value.to_s
 
-    def val(value, number, label = nil)
-      if value == :new
-        raise ArgumentError.new(":new is not allowed as enum value")
+      if RESTRICTED_METHODS.include?(method)
+        raise ArgumentError.new("#{method.inspect} is not allowed as enum method")
       end
-      
-      enum_value = values.add(value, number: number, label: label)
 
-      define_method "#{enum_value.value}" do
-        by_value(enum_value.value)
+      enum_value = @values.add(value, mapped_value, method)
+
+      define_method(enum_value.method) do
+        get_values.by_value(enum_value.value)
       end
 
-      define_singleton_method "#{enum_value.value}" do
-        by_value(enum_value.value)
+      define_singleton_method(enum_value.method) do
+        get_values.by_value(enum_value.value)
       end
 
       enum_value
     end
   end
 
-  def values
-    self.class.values
+  def get_values
+    self.class.get_values
   end
-
-  include CommonMethods
 end

data/lib/ree_lib/packages/ree_enum/package/ree_enum/value.rb

@@ -1,60 +1,41 @@
 # frozen_string_literal: true
 
 class ReeEnum::Value
-  attr_reader :enum_class, :enum_name, :value, :label, :number
+  attr_reader :enum_class, :enum_name, :value, :method, :mapped_value
 
-  contract(Class, Symbol, Symbol, Integer, Nilor[String] => Any)
-  def initialize(enum_class, enum_name, value, number, label)
+  contract(Class, Symbol, String, Or[Integer, String], Symbol => Any)
+  def initialize(enum_class, enum_name, value, mapped_value, method)
     @enum_class = enum_class
     @enum_name = enum_name
     @value = value
-    @label = label
-    @number = number
+    @method = method
+    @mapped_value = mapped_value
   end
 
   def to_s
-    @value.to_s
-  end
-
-  def to_sym
-    @value
-  end
-
-  def to_i
-    @number
+    value
   end
 
   def as_json(*args)
     to_s
   end
 
-  def label
-    @label
-  end
-
-  contract(Or[ReeEnum::Value, Symbol, Integer, Any] => Bool)
+  contract(Or[ReeEnum::Value, String, Symbol, Integer, Any] => Bool)
   def ==(compare)
     if compare.is_a?(self.class)
-      @value == compare.value
+      value == compare.value
+    elsif compare.is_a?(Symbol)
+      value == compare.to_s
+    elsif compare.is_a?(String)
+      value == compare || mapped_value == compare
+    elsif compare.is_a?(Integer)
+      mapped_value == compare
     else
-      @value == compare || @number == compare
+      false
     end
   end
 
-  contract(Or[ReeEnum::Value, String, Integer] => Bool)
-  def <=>(other)
-    if other.is_a?(self.class)
-      @number <=> other.number
-    elsif other.is_a?(Symbol)
-      @value == other
-    elsif other.is_a?(Integer)
-      @number == other
-    else
-      raise ArgumentError.new("unable to compare ReeEnum::Value with other classes")
-    end
-  end
-  
   def inspect
-    "#{enum_class.name}##{@value.to_s}"
+    "#{enum_class.name}##{value}"
   end
 end

data/lib/ree_lib/packages/ree_enum/package/ree_enum/values.rb

@@ -6,41 +6,67 @@ class ReeEnum::Values
   def initialize(klass, enum_name)
     @klass = klass
     @enum_name = enum_name
-    @collection = {}
+    @collection = []
+    @collection_by_value = {}
+    @collection_by_mapped_value = {}
   end
 
-  def all
-    @collection.values.sort_by(&:number)
+  def to_a
+    @collection
   end
 
-  contract(Symbol => ReeEnum::Value).throws(ArgumentError)
+  def each(&)
+    @collection.each(&)
+  end
+
+  contract(Or[Symbol, String] => Nilor[ReeEnum::Value])
   def by_value(value)
-    type = @collection.values.detect {|c| c.value == value}
-    type || (raise ArgumentError.new("constant for value #{value.inspect} is not found in #{self.inspect}"))
+    @collection_by_value[value.to_s]
+  end
+
+  contract(Or[Symbol, String] => ReeEnum::Value).throws(ArgumentError)
+  def by_value!(value)
+    by_value(value) ||
+      (raise ArgumentError.new("constant for value #{value.inspect} is not found in #{self.inspect}"))
+  end
+
+  contract(Or[Integer, String] => Nilor[ReeEnum::Value])
+  def by_mapped_value(mapped_value)
+    @collection_by_mapped_value[mapped_value]
   end
 
-  contract(Integer => ReeEnum::Value).throws(ArgumentError)
-  def by_number(number)
-    type = @collection.values.detect {|c| c.number == number}
-    type || (raise ArgumentError.new("constant for value #{number.inspect} is not found in #{self.inspect}"))
+  contract(Or[Integer, String] => ReeEnum::Value).throws(ArgumentError)
+  def by_mapped_value!(mapped_value)
+    by_mapped_value(mapped_value) ||
+      (raise ArgumentError.new("constant for value #{mapped_value.inspect} is not found in #{self.inspect}"))
   end
 
   def inspect
-    @collection.values.map(&:inspect).inspect
+    @collection.map(&:inspect).inspect
   end
 
-  contract(Symbol, Kwargs[number: Integer, label: Nilor[String]] => ReeEnum::Value)
-  def add(value, number:, label: nil)
-    if @collection.has_key?(value)
+  contract(String, Or[Integer, String], Symbol => ReeEnum::Value)
+  def add(value, mapped_value, method)
+    if @collection.any? { _1.method == method }
+      raise ArgumentError, "#{@klass}: method #{method.inspect} was already added"
+    end
+
+    if @collection_by_value.key?(value)
       raise ArgumentError, "#{@klass}: value #{value.inspect} was already added"
     end
 
-    if @collection.values.any? {|v| v.number == number}
-      raise ArgumentError, "number for #{value.inspect} was already added"
+    if @collection_by_mapped_value.key?(mapped_value)
+      raise ArgumentError, "#{@klass}: mapped_value(#{mapped_value.inspect}) for #{value.inspect} was already added"
     end
 
-    @collection[value] = ReeEnum::Value.new(
-      @klass, @enum_name, value, number, label
+    enum_value = ReeEnum::Value.new(
+      @klass, @enum_name, value, mapped_value, method
     )
+
+    @collection << enum_value
+    @collection_by_value[value] = enum_value
+    @collection_by_mapped_value[mapped_value] = enum_value
+
+    enum_value
   end
 end

data/lib/ree_lib/packages/ree_enum/spec/ree_enum/dsl_spec.rb

@@ -32,11 +32,20 @@ RSpec.describe ReeEnum::DSL do
 
         enum :types
 
-        val :account, 0
+        val :account
 
         register_as_mapper_type
       end
 
+      class Reflexives
+        include ReeEnum::DSL
+
+        enum :reflexives
+
+        val :self, method: :myself
+        val :yourself
+      end
+
       class TestMapper
         include ReeMapper::DSL
 
@@ -75,11 +84,11 @@ RSpec.describe ReeEnum::DSL do
       expect(o.first).to eq(0)
       expect(o.second).to eq(:second)
       expect(o.second).to eq(1)
-      expect(o.by_value(:first)).to eq(o.first)
-      expect(o.by_value(:second)).to eq(o.second)
-      expect(o.by_number(0)).to eq(o.first)
-      expect(o.by_number(1)).to eq(o.second)
-      expect(o.all).to eq([o.first, o.second])
+      expect(o.get_values.by_value(:first)).to eq(o.first)
+      expect(o.get_values.by_value(:second)).to eq(o.second)
+      expect(o.get_values.by_mapped_value(0)).to eq(o.first)
+      expect(o.get_values.by_mapped_value(1)).to eq(o.second)
+      expect(o.get_values.to_a).to eq([o.first, o.second])
     end
 
     expect {
@@ -146,18 +155,20 @@ RSpec.describe ReeEnum::DSL do
     ).to eq(
       {
         state: 0,
-        type: 0
+        type: "account"
       }
     )
 
     dto = mapper.db_load({
       state: 0,
-      type: 0,
+      type: "account",
     })
 
     expect(dto.state).to eq(TestReeEnum::States.first)
     expect(dto.state).to be_a(ReeEnum::Value)
     expect(dto.type).to eq(TestReeEnum::Types.account)
     expect(dto.type).to be_a(ReeEnum::Value)
+
+    expect(TestReeEnum::Reflexives.myself).to eq(:self)
   }
 end

data/lib/ree_lib/packages/ree_i18n/package/ree_i18n/functions/set_locale.rb

@@ -5,8 +5,8 @@ class ReeI18n::SetLocale
 
   fn :set_locale
 
-  contract(Symbol => Symbol).throws(I18n::InvalidLocale)
+  contract(Or[Symbol, String] => Symbol).throws(I18n::InvalidLocale)
   def call(locale)
-    I18n.locale = locale
+    I18n.locale = locale.to_sym
   end
 end

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

@@ -27,6 +27,7 @@ class ReeMapper::BuildMapperFactory
     klass.register_type(:integer, ReeMapper::Integer.new)
     klass.register_type(:string, ReeMapper::String.new)
     klass.register_type(:any, ReeMapper::Any.new)
+    klass.register_type(:rational, ReeMapper::Rational.new)
 
     klass.register_wrapper(:array, ReeMapper::Array)
 

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

@@ -12,8 +12,8 @@ class ReeMapper::Float < ReeMapper::AbstractType
 
   contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Float).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
   def cast(value, name:, role: nil)
-    if value.is_a?(Float)
-      value
+    if value.is_a?(Numeric)
+      value.to_f
     elsif value.is_a?(String)
       begin
         Float(value)

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class ReeMapper::Rational < ReeMapper::AbstractType
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational).throws(ReeMapper::TypeError)
+  def serialize(value, name:, role: nil)
+    if value.is_a?(Rational)
+      value
+    else
+      raise ReeMapper::TypeError, "`#{name}` should be a rational"
+    end
+  end
+
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational).throws(ReeMapper::CoercionError, ReeMapper::TypeError)
+  def cast(value, name:, role: nil)
+    if value.is_a?(Rational)
+      value
+    elsif value.is_a?(String)
+      begin
+        Rational(value)
+      rescue ArgumentError, ZeroDivisionError => e
+        raise ReeMapper::CoercionError, "`#{name}` is invalid rational"
+      end
+    elsif value.is_a?(Numeric)
+      Rational(value)
+    else
+      raise ReeMapper::TypeError, "`#{name}` should be a rational"
+    end
+  end
+
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => String)
+  def db_dump(value, name:, role: nil)
+    serialize(value, name: name, role: role).to_s
+  end
+
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Rational)
+  def db_load(value, name:, role: nil)
+    cast(value, name: name, role: role)
+  end
+end

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

@@ -34,6 +34,7 @@ module ReeMapper
   require_relative 'ree_mapper/types/float'
   require_relative 'ree_mapper/types/integer'
   require_relative 'ree_mapper/types/string'
+  require_relative 'ree_mapper/types/rational'
 
   require_relative 'ree_mapper/strategy_outputs/strategy_output'
   require_relative 'ree_mapper/strategy_outputs/object_output'

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/float_spec.rb

@@ -32,7 +32,11 @@ RSpec.describe 'ReeMapper::Float' do
     }
 
     it {
-      expect(mapper.db_load({ float: BigDecimal("1.1") })).to eq({ float: 1.1 })
+      expect(mapper.cast({ float: BigDecimal("1.1") })).to eq({ float: 1.1 })
+    }
+
+    it {
+      expect(mapper.cast({ float: 1 })).to eq({ float: 1.0 })
     }
 
     it {
@@ -40,7 +44,7 @@ RSpec.describe 'ReeMapper::Float' do
     }
 
     it {
-      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
+      expect { mapper.cast({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }
 
     it {
@@ -97,6 +101,10 @@ RSpec.describe 'ReeMapper::Float' do
       expect(mapper.db_load({ float: BigDecimal("1.1") })).to eq({ float: 1.1 })
     }
 
+    it {
+      expect(mapper.db_load({ float: 1 })).to eq({ float: 1.0 })
+    }
+
     it {
       expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float')
     }

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/rational_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+require 'bigdecimal'
+
+RSpec.describe 'ReeMapper::Rational' do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast, dto: Hash),
+        build_mapper_strategy(method: :serialize, dto: Hash),
+        build_mapper_strategy(method: :db_dump, dto: Hash),
+        build_mapper_strategy(method: :db_load, dto: Hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      rational :rational
+    }
+  }
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ rational: Rational("1/3") })).to eq({ rational: Rational("1/3") })
+    }
+
+    it {
+      expect(mapper.cast({ rational: 0.33 })).to eq({ rational: Rational(0.33) })
+    }
+
+    it {
+      expect(mapper.cast({ rational: '0.33' })).to eq({ rational: Rational('0.33') })
+    }
+
+    it {
+      expect(mapper.cast({ rational: BigDecimal("0.33") })).to eq({ rational: Rational(BigDecimal("0.33")) })
+    }
+
+    it {
+      expect { mapper.cast({ rational: 'a333' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational')
+    }
+
+    it {
+      expect { mapper.cast({ rational: '333a' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational')
+    }
+
+    it {
+      expect { mapper.cast({ rational: Object.new }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+  end
+
+  describe '#serialize' do
+    it {
+      expect(mapper.serialize({ rational: Rational("1/3") })).to eq({ rational: Rational("1/3") })
+    }
+
+    it {
+      expect { mapper.serialize({ rational: '1/3' }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+
+    it {
+      expect { mapper.serialize({ rational: nil }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+
+    it {
+      expect { mapper.serialize({ rational: Object.new }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+  end
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump({ rational: Rational("1/3") })).to eq({ rational: "1/3" })
+    }
+
+    it {
+      expect { mapper.db_dump({ rational: '1/3' }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+
+    it {
+      expect { mapper.db_dump({ rational: nil }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+
+    it {
+      expect { mapper.db_dump({ rational: Object.new }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({ rational: Rational("1/3") })).to eq({ rational: Rational("1/3") })
+    }
+
+    it {
+      expect(mapper.db_load({ rational: 0.33 })).to eq({ rational: Rational(0.33) })
+    }
+
+    it {
+      expect(mapper.db_load({ rational: '0.33' })).to eq({ rational: Rational('0.33') })
+    }
+
+    it {
+      expect(mapper.db_load({ rational: BigDecimal("0.33") })).to eq({ rational: Rational(BigDecimal("0.33")) })
+    }
+
+    it {
+      expect { mapper.db_load({ rational: 'a333' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational')
+    }
+
+    it {
+      expect { mapper.db_load({ rational: '333a' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational')
+    }
+
+    it {
+      expect { mapper.db_load({ rational: Object.new }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational")
+    }
+  end
+end

data/lib/ree_lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.69"
+  VERSION = "1.0.71"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.69
+  version: 1.0.71
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-25 00:00:00.000000000 Z
+date: 2023-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -1022,6 +1022,7 @@ files:
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/date_time.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/float.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/integer.rb
+- lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/rational.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/string.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/time.rb
 - lib/ree_lib/packages/ree_mapper/package/ree_mapper/wrappers/abstract_wrapper.rb
@@ -1042,6 +1043,7 @@ files:
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/float_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/hash_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/integer_spec.rb
+- lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/rational_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/string_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/time_spec.rb
 - lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/type_options_spec.rb