ree_lib 1.0.72 → 1.0.73

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0421ad28472f902b4c53091515c749bdcb6aba9ef96ed42009abe27d115edf48
-  data.tar.gz: 3909bfecb3e92e05708a9be5effb672fc8042e2f53ed4aadb426539f0eba8574
+  metadata.gz: 8bc7c01750d09b6274eabf44aa42ab5df1638372eed12a81bf2f79d09caf2920
+  data.tar.gz: 8dd947819db285b9ead46579f4eacb3b482a27fa525f48e0f997f21ac230744e
 SHA512:
-  metadata.gz: bb696f99d8af84de496f0e6a3bf616256853302d952409832fd89eb24830c0f29cb2cead19b245eee883a2c9dc7d358633bccc308be56369c2d8aeb569a66c7d
-  data.tar.gz: 0accc79d4259f341f4fbf6306103e28521b070119b2ee6be3e7bb98e08802b78ad857f476524a128d9c51cd7ca02fb59298ac70886b70a1304de8d39455d13d5
+  metadata.gz: 498b93f53f71563223d74404aa958ea60618c3513c21a9344ae6c18bce4fd6664113eb47aae7f4626577c632417f355a09252411ebe244921c1443f5846c8e3c
+  data.tar.gz: d1c3ac12551051f7f9b5f71e785e4cbe22bc5854863b8e406c6b3f950ed486043c9f9c2fffc88ce2c95df471aab47f3c3401af2b6c353bffb2c22bd24d867619

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.72)
+    ree_lib (1.0.73)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -51,7 +51,7 @@ GEM
       rack (>= 1.3)
     rainbow (3.1.1)
     rake (13.0.6)
-    ree (1.0.29)
+    ree (1.0.31)
       commander (~> 4.6.0)
     rexml (3.2.5)
     roda (3.58.0)

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative "value"
+
+class ReeEnum::BaseEnumMapper < ReeMapper::AbstractType
+  def initialize(enum)
+    @enum = enum
+  end
+
+  contract(
+    ReeEnum::Value,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]]
+    ] => Or[Integer, String]
+  )
+  def db_dump(value, name:, role: nil)
+    value.mapped_value
+  end
+
+  contract(
+    Or[Integer, String],
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]]
+    ] => ReeEnum::Value
+  ).throws(ReeMapper::CoercionError)
+  def db_load(value, name:, role: nil)
+    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_inspection ||= 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

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

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
 package_require 'ree_swagger/functions/register_type'
 
+require_relative 'integer_value_enum_mapper'
+require_relative 'string_value_enum_mapper'
+
 module ReeEnum
   module DSL
     def self.included(base)
@@ -27,100 +31,32 @@ module ReeEnum
       end
 
       def type_for_mapper
-        @type_for_mapper ||= begin
-          klass = Class.new(ReeMapper::AbstractType) do
-            def initialize(enum)
-              @enum = enum
-            end
-
-            contract(
-              ReeEnum::Value,
-              Kwargs[
-                name: String,
-                role: Nilor[Symbol, ArrayOf[Symbol]]
-              ] => String
-            )
-            def serialize(value, name:, role: nil)
-              value.to_s
-            end
-
-            contract(
-              Any,
-              Kwargs[
-                name: String,
-                role: Nilor[Symbol, ArrayOf[Symbol]]
-              ] => ReeEnum::Value
-            ).throws(ReeMapper::CoercionError)
-            def cast(value, name:, role: nil)
-              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
-
-              if enum_value.nil?
-                raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}"
-              end
-
-              enum_value
-            end
-
-            contract(
-              ReeEnum::Value,
-              Kwargs[
-                name: String,
-                role: Nilor[Symbol, ArrayOf[Symbol]]
-              ] => Or[Integer, String]
-            )
-            def db_dump(value, name:, role: nil)
-              value.mapped_value
-            end
-
-            contract(
-              Or[Integer, String],
-              Kwargs[
-                name: String,
-                role: Nilor[Symbol, ArrayOf[Symbol]]
-              ] => ReeEnum::Value
-            ).throws(ReeMapper::CoercionError)
-            def db_load(value, name:, role: nil)
-              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
-
-          klass.new(self)
+        return @type_for_mapper if defined? @type_for_mapper
+
+        value_type = get_values.value_type
+
+        klass = if value_type == String
+          StringValueEnumMapper
+        elsif value_type == Integer
+          IntegerValueEnumMapper
+        else
+          raise NotImplementedError, "value_type #{value_type} is not supported"
         end
+
+        @type_for_mapper = klass.new(self)
       end
 
       def register_as_swagger_type
         swagger_type_registrator = ReeSwagger::RegisterType.new
 
+        definition = swagger_definition
+
         [:casters, :serializers].each do |kind|
           swagger_type_registrator.call(
             kind,
             type_for_mapper.class,
             ->(*) {
-              {
-                type: 'string',
-                enum: get_values.each.map(&:to_s)
-              }
+              definition
             }
           )
         end
@@ -137,6 +73,23 @@ module ReeEnum
           self.get_enum_name, type_for_mapper
         )
       end
+
+      def swagger_definition
+        value_type = get_values.value_type
+
+        type = if value_type == String
+          "string"
+        elsif value_type == Integer
+          "integer"
+        else
+          raise NotImplementedError, "value_type #{value_type} is not supported"
+        end
+
+        {
+          type: type,
+          enum: get_values.each.map(&:value)
+        }
+      end
     end
   end
 end

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

@@ -29,8 +29,9 @@ module ReeEnum::Enumerable
       @values&.enum_name
     end
 
-    def val(value, mapped_value = value.to_s, method: value.to_sym)
-      value = value.to_s
+    def val(value, mapped_value = nil, method: value.to_s.to_sym)
+      value = value.to_s if value.is_a?(Symbol)
+      mapped_value ||= value
 
       if RESTRICTED_METHODS.include?(method)
         raise ArgumentError.new("#{method.inspect} is not allowed as enum method")
@@ -38,13 +39,15 @@ module ReeEnum::Enumerable
 
       enum_value = @values.add(value, mapped_value, method)
 
-      define_method(enum_value.method) do
-        get_values.by_value(enum_value.value)
-      end
+      class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def #{method}
+          get_values.by_value(#{value.inspect}.freeze)
+        end
 
-      define_singleton_method(enum_value.method) do
-        get_values.by_value(enum_value.value)
-      end
+        def self.#{method}
+          get_values.by_value(#{value.inspect}.freeze)
+        end
+      RUBY
 
       enum_value
     end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require_relative "base_enum_mapper"
+
+class ReeEnum::IntegerValueEnumMapper < ReeEnum::BaseEnumMapper
+  contract(
+    ReeEnum::Value,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]]
+    ] => Integer
+  )
+  def serialize(value, name:, role: nil)
+    value.value
+  end
+
+  contract(
+    Any,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]]
+    ] => ReeEnum::Value
+  ).throws(ReeMapper::CoercionError)
+  def cast(value, name:, role: nil)
+    enum_value = case value
+    when Integer
+      @enum.get_values.by_value(value)
+    when String
+      value = Integer(value, exception: false)
+      if !value.nil?
+        @enum.get_values.by_value(value)
+      end
+    when ReeEnum::Value
+      @enum.get_values.each.find { _1 == value }
+    end
+
+    if enum_value.nil?
+      raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}"
+    end
+
+    enum_value
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative "base_enum_mapper"
+
+class ReeEnum::StringValueEnumMapper < ReeEnum::BaseEnumMapper
+  contract(
+    ReeEnum::Value,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]]
+    ] => String
+  )
+  def serialize(value, name:, role: nil)
+    value.value
+  end
+
+  contract(
+    Any,
+    Kwargs[
+      name: String,
+      role: Nilor[Symbol, ArrayOf[Symbol]]
+    ] => ReeEnum::Value
+  ).throws(ReeMapper::CoercionError)
+  def cast(value, name:, role: nil)
+    enum_value = case value
+    when String
+      @enum.get_values.by_value(value)
+    when ReeEnum::Value
+      @enum.get_values.each.find { _1 == value }
+    end
+
+    if enum_value.nil?
+      raise ReeMapper::CoercionError, "`#{name}` should be one of #{enum_inspection}"
+    end
+
+    enum_value
+  end
+end

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

@@ -3,7 +3,7 @@
 class ReeEnum::Value
   attr_reader :enum_class, :enum_name, :value, :method, :mapped_value
 
-  contract(Class, Symbol, String, Or[Integer, String], Symbol => Any)
+  contract(Class, Symbol, Or[String, Integer], Or[Integer, String], Symbol => Any)
   def initialize(enum_class, enum_name, value, mapped_value, method)
     @enum_class = enum_class
     @enum_name = enum_name
@@ -13,25 +13,21 @@ class ReeEnum::Value
   end
 
   def to_s
-    value
+    value.to_s
   end
 
   def as_json(*args)
-    to_s
+    value
   end
 
   contract(Or[ReeEnum::Value, String, Symbol, Integer, Any] => Bool)
   def ==(compare)
     if compare.is_a?(self.class)
       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
+    elsif compare.is_a?(Symbol) && value.is_a?(String)
+      value.to_sym == compare
     else
-      false
+      value == compare || mapped_value == compare
     end
   end
 

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

@@ -11,6 +11,11 @@ class ReeEnum::Values
     @collection_by_mapped_value = {}
   end
 
+  def value_type
+    raise ArgumentError, "value_type is not defined" unless defined?(@value_type)
+    @value_type
+  end
+
   def to_a
     @collection
   end
@@ -19,12 +24,13 @@ class ReeEnum::Values
     @collection.each(&)
   end
 
-  contract(Or[Symbol, String] => Nilor[ReeEnum::Value])
+  contract(Or[Symbol, String, Integer] => Nilor[ReeEnum::Value])
   def by_value(value)
-    @collection_by_value[value.to_s]
+    value = value.to_s if value.is_a?(Symbol)
+    @collection_by_value[value]
   end
 
-  contract(Or[Symbol, String] => ReeEnum::Value).throws(ArgumentError)
+  contract(Or[Symbol, String, Integer] => 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}"))
@@ -45,8 +51,14 @@ class ReeEnum::Values
     @collection.map(&:inspect).inspect
   end
 
-  contract(String, Or[Integer, String], Symbol => ReeEnum::Value)
+  contract(Or[String, Integer], Or[Integer, String], Symbol => ReeEnum::Value)
   def add(value, mapped_value, method)
+    if @value_type.nil?
+      @value_type = value.class
+    elsif @value_type != value.class
+      raise ArgumentError, "#{@klass}: value types should be the same for all enum values"
+    end
+
     if @collection.any? { _1.method == method }
       raise ArgumentError, "#{@klass}: method #{method.inspect} was already added"
     end

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

@@ -37,6 +37,17 @@ RSpec.describe ReeEnum::DSL do
         register_as_mapper_type
       end
 
+      class Numbers
+        include ReeEnum::DSL
+
+        enum :numbers
+
+        val 0, method: :zero
+        val 1, method: :one
+
+        register_as_mapper_type
+      end
+
       class Reflexives
         include ReeEnum::DSL
 
@@ -52,19 +63,22 @@ RSpec.describe ReeEnum::DSL do
         mapper :test_mapper do
           link :states
           link :types
+          link :numbers
         end
 
         class Dto
-          attr_reader :type, :state
-          def initialize(type, state)
+          attr_reader :type, :state, :number
+          def initialize(type, state, number)
             @type = type
             @state = state
+            @number = number
           end
         end
 
         build_mapper.use(:serialize).use(:cast).use(:db_dump).use(:db_load, dto: Dto) do
           types :type
           states :state
+          numbers :number
         end
       end
 
@@ -86,6 +100,8 @@ RSpec.describe ReeEnum::DSL do
       expect(o.second).to eq(1)
       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_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])
@@ -108,11 +124,13 @@ RSpec.describe ReeEnum::DSL do
       mapper.serialize({
         state: TestReeEnum::States.first,
         type: TestReeEnum::Types.account,
+        number: TestReeEnum::Numbers.zero,
       })
     ).to eq(
       {
         state: 'first',
-        type: 'account'
+        type: 'account',
+        number: 0,
       }
     )
 
@@ -120,6 +138,7 @@ RSpec.describe ReeEnum::DSL do
       mapper.cast({
         state: 'first',
         type: 'invalid',
+        number: 0,
       })
       }.to raise_error(ReeMapper::CoercionError, '`type` should be one of ["account"]')
 
@@ -127,11 +146,13 @@ RSpec.describe ReeEnum::DSL do
       mapper.cast({
         state: 'first',
         type: 'account',
+        number: 0,
       })
     ).to eq(
       {
         state: TestReeEnum::States.first,
-        type: TestReeEnum::Types.account
+        type: TestReeEnum::Types.account,
+        number: TestReeEnum::Numbers.zero,
       }
     )
 
@@ -139,11 +160,27 @@ RSpec.describe ReeEnum::DSL do
       mapper.cast({
         state: TestReeEnum::States.first,
         type: TestReeEnum::Types.account,
+        number: TestReeEnum::Numbers.zero,
       })
     ).to eq(
       {
         state: TestReeEnum::States.first,
-        type: TestReeEnum::Types.account
+        type: TestReeEnum::Types.account,
+        number: TestReeEnum::Numbers.zero,
+      }
+    )
+
+    expect(
+      mapper.cast({
+        state: TestReeEnum::States.first,
+        type: TestReeEnum::Types.account,
+        number: TestReeEnum::Numbers.zero,
+      })
+    ).to eq(
+      {
+        state: "first",
+        type: "account",
+        number: 0,
       }
     )
 
@@ -151,23 +188,28 @@ RSpec.describe ReeEnum::DSL do
       mapper.db_dump({
         state: TestReeEnum::States.first,
         type: TestReeEnum::Types.account,
+        number: TestReeEnum::Numbers.zero,
       })
     ).to eq(
       {
         state: 0,
-        type: "account"
+        type: "account",
+        number: 0,
       }
     )
 
     dto = mapper.db_load({
       state: 0,
       type: "account",
+      number: 0,
     })
 
     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(dto.number).to eq(TestReeEnum::Numbers.zero)
+    expect(dto.number).to be_a(ReeEnum::Value)
 
     expect(TestReeEnum::Reflexives.myself).to eq(:self)
   }

data/lib/ree_lib/packages/ree_hash/package/ree_hash/functions/slice.rb

@@ -6,14 +6,15 @@ class ReeHash::Slice
   fn :slice do
     link :build_filter_keys
     link 'ree_hash/contracts/hash_keys_contract', -> { HashKeysContract }
-    def_error { MissingKeyErr }
-    def_error { InvalidFilterKey }
   end
 
+  MissingKeyErr = Class.new(ArgumentError)
+  InvalidFilterKey = Class.new(ArgumentError)
+
   doc(<<~DOC)
     Replaces the hash with only the given keys.
     Returns a hash containing the removed key/value pairs.
-    
+
       hash = { a: 1, b: {e: 2, f: 1}, c: 3, d: 4 }
       slice(hash, [:a, :b])  # => {a: 1, b: 2}
       slice(hash, [:a, b: [:e]])  # => {a: 1, b: {e: 2}}

data/lib/ree_lib/packages/ree_i18n/schemas/ree_i18n/functions/set_locale.schema.json

@@ -17,7 +17,7 @@
         {
           "arg": "locale",
           "arg_type": "req",
-          "type": "Symbol"
+          "type": "Or[Symbol, String]"
         }
       ]
     }

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

@@ -15,11 +15,11 @@ class ReeMapper::Integer < ReeMapper::AbstractType
     if value.is_a?(Integer)
       value
     elsif value.is_a?(String)
-      begin
-        Integer(value)
-      rescue ArgumentError => e
+      value = Integer(value, exception: false)
+      if value.nil?
         raise ReeMapper::CoercionError, "`#{name}` is invalid integer"
       end
+      value
     else
       raise ReeMapper::TypeError, "`#{name}` should be an integer"
     end

data/lib/ree_lib/packages/ree_object/package/ree_object/functions/to_hash.rb

@@ -3,9 +3,9 @@
 class ReeObject::ToHash
   include Ree::FnDSL
 
-  fn :to_hash do
-    def_error { RecursiveObjectErr }
-  end
+  fn :to_hash
+
+  RecursiveObjectErr = Class.new(ArgumentError)
 
   BASIC_TYPES = [
     Date, Time, Numeric, String, FalseClass, TrueClass, NilClass, Symbol,

data/lib/ree_lib/ree.setup.rb

@@ -1,7 +1 @@
-Ree.add_error_types(
-  :invalid_param,
-  :not_found,
-  :validation
-)
-
 Ree.set_performance_mode

data/lib/ree_lib/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ree_lib
 version: !ruby/object:Gem::Version
-  version: 1.0.72
+  version: 1.0.73
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-28 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree
@@ -809,9 +809,12 @@ files:
 - lib/ree_lib/packages/ree_enum/Package.schema.json
 - lib/ree_lib/packages/ree_enum/bin/console
 - lib/ree_lib/packages/ree_enum/package/ree_enum.rb
+- lib/ree_lib/packages/ree_enum/package/ree_enum/base_enum_mapper.rb
 - lib/ree_lib/packages/ree_enum/package/ree_enum/contractable.rb
 - lib/ree_lib/packages/ree_enum/package/ree_enum/dsl.rb
 - lib/ree_lib/packages/ree_enum/package/ree_enum/enumerable.rb
+- lib/ree_lib/packages/ree_enum/package/ree_enum/integer_value_enum_mapper.rb
+- lib/ree_lib/packages/ree_enum/package/ree_enum/string_value_enum_mapper.rb
 - lib/ree_lib/packages/ree_enum/package/ree_enum/value.rb
 - lib/ree_lib/packages/ree_enum/package/ree_enum/values.rb
 - lib/ree_lib/packages/ree_enum/spec/package_schema_spec.rb