ree_lib 1.0.69 → 1.0.70

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c746828c8b09f58c0406659649ef01ba7b7300f4b1f35f808f8e1f58a0dc4165
-  data.tar.gz: c03ddd00be42dbbe2ee2e2660a105a84912d19ccb5251fd882bd88d04e5bd781
+  metadata.gz: 40e7e6a91b65f1bab58b667f1eebf153ac5fd1c85852e189af8d3a6d2ea8b163
+  data.tar.gz: 5ac2658d206e2aa8963fd90ed4ca4ef071b701a0d02414d571dcc95df825a88e
 SHA512:
-  metadata.gz: 5fa6ca950b18d4e6678610f8dd1b1d3c239090e18d7c914be33643e75d846332e041109d8cb2f6d301398e9eafeeb6897320bfac688c2defb427bc2bec6a4e5c
-  data.tar.gz: 13405b30d0b4be4aba5e579f8bab5a410af29fe820a5aca37502ea6a7d356a5d5fdad315214fa70b8581927c7ee712607a101b191ec2d9fd383a4b4e1989f8a8
+  metadata.gz: 221b1612a9ddc52b73f6cd34a1f1228009a3459646d0f129281d5c4ae16557e1044359cb13e44085bf1e727ae07ce3be7cfae9e1728fae8260ed42f888a52010
+  data.tar.gz: e296d1413246f6813ec865ae1395eec11f71f2066d755d815ccac8a260278f122c20e6ca0c680204245a693aa9668dfaab46c0187e25e51288be6c4d523c5e7a

data/Gemfile.lock

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

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,45 @@
 # 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
+    value
   end
 
-  def to_sym
-    @value
-  end
-
-  def to_i
-    @number
+  def to_sql
+    mapped_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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.69"
+  VERSION = "1.0.70"
 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.70
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-25 00:00:00.000000000 Z
+date: 2023-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ree