ree_lib 1.0.68 → 1.0.70

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a34603f1dd69c0e4eecca51ac58f30e000fd673da8f157901eb085671b7d9e04
-  data.tar.gz: ddd8255a1b09641a1d88869e8c664415b44c1a3e8669c907459fd14bcd709743
+  metadata.gz: 40e7e6a91b65f1bab58b667f1eebf153ac5fd1c85852e189af8d3a6d2ea8b163
+  data.tar.gz: 5ac2658d206e2aa8963fd90ed4ca4ef071b701a0d02414d571dcc95df825a88e
 SHA512:
-  metadata.gz: 1e07c24f16571cbdadf18a7f5013a87d488d230663f89524d927dd1998835365293b83e42bce61e8ceac2871762b16102130efe26419e2ef5270bc5ee2597db7
-  data.tar.gz: 6ca2018732da00c6205c048bb1011738694174a8b76930973625567db74e6bca9ad86aea6764e503ddb4f915853ce603160e0bd194f229587c018ac7e98cd156
+  metadata.gz: 221b1612a9ddc52b73f6cd34a1f1228009a3459646d0f129281d5c4ae16557e1044359cb13e44085bf1e727ae07ce3be7cfae9e1728fae8260ed42f888a52010
+  data.tar.gz: e296d1413246f6813ec865ae1395eec11f71f2066d755d815ccac8a260278f122c20e6ca0c680204245a693aa9668dfaab46c0187e25e51288be6c4d523c5e7a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.68)
+    ree_lib (1.0.70)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -37,10 +37,10 @@ GEM
     loofah (2.18.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
-    mini_portile2 (2.8.1)
     msgpack (1.6.0)
-    nokogiri (1.13.10)
-      mini_portile2 (~> 2.8.0)
+    nokogiri (1.15.4-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.4-x86_64-linux)
       racc (~> 1.4)
     oj (3.13.23)
     pg (1.4.6)

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

@@ -8,12 +8,12 @@ module ReeDao
     link :index_by, from: :ree_array
     link :underscore, from: :ree_string
 
-    attr_reader :parent, :parent_dao_name, :list, :global_opts
+    attr_reader :parent, :parent_dao, :list, :global_opts
 
-    contract(ReeDao::Associations, Symbol, Array, Ksplat[RestKeys => Any] => Any)
-    def initialize(parent, parent_dao_name, list, **global_opts)
+    contract(ReeDao::Associations, Sequel::Dataset, Array, Ksplat[RestKeys => Any] => Any)
+    def initialize(parent, parent_dao, list, **global_opts)
       @parent = parent
-      @parent_dao_name = parent_dao_name
+      @parent_dao = parent_dao
       @list = list
       @global_opts = global_opts
     end
@@ -36,7 +36,7 @@ module ReeDao
       Or[:belongs_to, :has_one, :has_many],
       Symbol,
       Ksplat[RestKeys => Any],
-      Optblock => Nilor[Array]
+      Optblock => Array
     )
     def load_association(assoc_type, assoc_name, **__opts, &block)
       __opts[:autoload_children] ||= false
@@ -47,21 +47,17 @@ module ReeDao
         **__opts
       )
 
-      dao = find_dao(assoc_name, parent, __opts[:scope])
-
-      dao_name = if dao
-        dao.first_source_table
-      elsif __opts[:scope].is_a?(Array)
-        name = underscore(demodulize(__opts[:scope].first.class.name))
+      scope = __opts[:scope]
 
-        if name.end_with?("s")
-          "#{name}es"
-        else
-          "#{name}s"
-        end
+      dao = if scope.is_a?(Array)
+        return [] if scope.empty?
+        name = underscore(demodulize(scope.first.class.name))
+        find_dao(name, parent, nil)
+      else
+        find_dao(assoc_name, parent, scope)
       end
 
-      process_block(assoc_index, __opts[:autoload_children], __opts[:to_dto], dao_name, &block) if block_given?
+      process_block(assoc_index, __opts[:autoload_children], __opts[:to_dto], dao, &block) if block_given?
 
       list
     end
@@ -75,7 +71,7 @@ module ReeDao
       case type
       when :belongs_to
         one_to_one(
-          parent_dao_name,
+          parent_dao,
           assoc_name,
           list,
           scope: __opts[:scope],
@@ -86,7 +82,7 @@ module ReeDao
         )
       when :has_one
         one_to_one(
-          parent_dao_name,
+          parent_dao,
           assoc_name,
           list,
           scope: __opts[:scope],
@@ -98,7 +94,7 @@ module ReeDao
         )
       when :has_many
         one_to_many(
-          parent_dao_name,
+          parent_dao,
           assoc_name,
           list,
           scope: __opts[:scope],
@@ -110,8 +106,8 @@ module ReeDao
       end
     end
 
-    contract(Or[Hash, Array], Bool, Nilor[Proc], Symbol, Block => Any)
-    def process_block(assoc, autoload_children, to_dto, parent_dao_name, &block)
+    contract(Or[Hash, Array], Bool, Nilor[Proc], Sequel::Dataset, Block => Any)
+    def process_block(assoc, autoload_children, to_dto, parent_dao, &block)
       assoc_list = assoc.is_a?(Array) ? assoc : assoc.values.flatten
 
       if to_dto
@@ -124,13 +120,12 @@ module ReeDao
         parent.agg_caller,
         assoc_list,
         parent.local_vars,
-        parent_dao_name,
+        parent_dao,
         autoload_children,
         **global_opts
       )
-      parent_dao = find_dao(parent_dao_name, parent.agg_caller)
 
-      if dao_in_transaction?(parent_dao) || ReeDao::Associations.sync_mode?
+      if parent_dao.db.in_transaction? || ReeDao::Associations.sync_mode?
         associations.instance_exec(assoc_list, &block)
       else
         threads = associations.instance_exec(assoc_list, &block)
@@ -150,7 +145,7 @@ module ReeDao
     end
 
     contract(
-      Symbol,
+      Sequel::Dataset,
       Symbol,
       Array,
       Kwargs[
@@ -162,7 +157,7 @@ module ReeDao
         reverse: Bool
       ] => Or[Hash, Array]
     )
-    def one_to_one(parent_assoc_name, assoc_name, list, scope: nil, primary_key: :id, foreign_key: nil, setter: nil, to_dto: nil, reverse: true)
+    def one_to_one(parent_dao, assoc_name, list, scope: nil, primary_key: :id, foreign_key: nil, setter: nil, to_dto: nil, reverse: true)
       return {} if list.empty?
 
       primary_key ||= :id
@@ -175,7 +170,7 @@ module ReeDao
         if reverse
           # has_one
           if !foreign_key
-            foreign_key = "#{parent_assoc_name.to_s.gsub(/s$/,'')}_id".to_sym
+            foreign_key = "#{parent_dao.first_source_table.to_s.gsub(/s$/,'')}_id".to_sym
           end
 
           root_ids = list.map(&:id).uniq
@@ -211,7 +206,7 @@ module ReeDao
     end
 
     contract(
-      Symbol,
+      Sequel::Dataset,
       Symbol,
       Array,
       Kwargs[
@@ -222,7 +217,7 @@ module ReeDao
         to_dto: Nilor[Proc]
       ] => Or[Hash, Array]
     )
-    def one_to_many(parent_assoc_name, assoc_name, list, primary_key: nil, foreign_key: nil, scope: nil, setter: nil, to_dto: nil)
+    def one_to_many(parent_dao, assoc_name, list, primary_key: nil, foreign_key: nil, scope: nil, setter: nil, to_dto: nil)
       return {} if list.empty?
 
       primary_key ||= :id
@@ -233,7 +228,7 @@ module ReeDao
         assoc_dao = nil
         assoc_dao = find_dao(assoc_name, parent, scope)
 
-        foreign_key ||= "#{parent_assoc_name.to_s.gsub(/s$/, '')}_id".to_sym
+        foreign_key ||= "#{parent_dao.first_source_table.to_s.gsub(/s$/, '')}_id".to_sym
 
         root_ids = list.map(&:"#{primary_key}")
 

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

@@ -9,25 +9,20 @@ module ReeDao
     end
 
     module InstanceMethods
+      SUFFIXES = ["", "s", "es", "dao", "s_dao", "es_dao"].freeze
+
       def find_dao(assoc_name, parent_caller, scope = nil)
-        dao_from_name = parent_caller.instance_variable_get("@#{assoc_name}") || parent_caller.instance_variable_get("@#{assoc_name}s")
-        return dao_from_name if dao_from_name
-  
-        raise ArgumentError, "can't find DAO for :#{assoc_name}, provide correct scope or association name" if scope.nil?
-        return nil if scope.is_a?(Array)
-  
-        table_name = scope.first_source_table
-        dao_from_scope = parent_caller.instance_variable_get("@#{table_name}")
-        return dao_from_scope if dao_from_scope
-  
+        SUFFIXES.each do |suffix|
+          dao_from_name = parent_caller.instance_variable_get("@#{assoc_name}#{suffix}")
+          return dao_from_name if dao_from_name
+        end
+
+        if scope.is_a?(Sequel::Dataset)
+          return scope.unfiltered
+        end
+
         raise ArgumentError, "can't find DAO for :#{assoc_name}, provide correct scope or association name"
       end
-    
-      def dao_in_transaction?(dao)
-        return false if dao.nil?
-    
-        dao.db.in_transaction?
-      end
     end
   end
 end

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

@@ -3,23 +3,23 @@ module ReeDao
     include Ree::LinkDSL
     include ReeDao::AssociationMethods
 
-    attr_reader :agg_caller, :list, :local_vars, :only, :except, :parent_dao_name, :autoload_children, :global_opts
+    attr_reader :agg_caller, :list, :local_vars, :only, :except, :parent_dao, :autoload_children, :global_opts
 
-    def initialize(agg_caller, list, local_vars, parent_dao_name, autoload_children = false, **opts)
+    def initialize(agg_caller, list, local_vars, parent_dao, autoload_children = false, **opts)
       @agg_caller = agg_caller
       @list = list
       @local_vars = local_vars
       @global_opts = opts || {}
       @only = opts[:only] if opts[:only]
       @except = opts[:except] if opts[:except]
-      @parent_dao_name = parent_dao_name
+      @parent_dao = parent_dao
       @autoload_children = autoload_children
 
       if @only && @except
         shared_keys = @only.intersection(@except)
 
         if shared_keys.size > 0
-          raise ArgumentError.new("you can't use both :only and :except for #{shared_keys.map { "\"#{_1}\"" }.join(", ")} keys") 
+          raise ArgumentError.new("you can't use both :only and :except for #{shared_keys.map { "\"#{_1}\"" }.join(", ")} keys")
         end
       end
 
@@ -87,12 +87,10 @@ module ReeDao
       Optblock => Any
     )
     def association(assoc_type, assoc_name, __opts, &block)
-      parent_dao = find_dao(parent_dao_name, agg_caller)
-
-      if dao_in_transaction?(parent_dao) || self.class.sync_mode?
+      if parent_dao.db.in_transaction? || self.class.sync_mode?
         return if association_is_not_included?(assoc_name) || list.empty?
 
-        association = Association.new(self, parent_dao_name, list, **global_opts)
+        association = Association.new(self, parent_dao, list, **global_opts)
 
         if assoc_type == :field
           association.handle_field(assoc_name, __opts)
@@ -104,7 +102,7 @@ module ReeDao
           return { association_threads: @assoc_threads, field_threads: @field_threads }
         end
 
-        association = Association.new(self, parent_dao_name, list, **global_opts)
+        association = Association.new(self, parent_dao, list, **global_opts)
 
         if assoc_type == :field
           field_proc = __opts

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

@@ -2,18 +2,15 @@
 
 class ReeDao::Agg
   include Ree::FnDSL
-  include ReeDao::AssociationMethods
 
   fn :agg do
-    link :demodulize, from: :ree_string
-    link :underscore, from: :ree_string
     link "ree_dao/associations", -> { Associations }
     link "ree_dao/contract/dao_dataset_contract", -> { DaoDatasetContract }
     link "ree_dao/contract/entity_contract", -> { EntityContract }
   end
 
   contract(
-    Nilor[DaoDatasetContract],
+    DaoDatasetContract,
     Or[Sequel::Dataset, ArrayOf[Integer], ArrayOf[EntityContract], Integer],
     Ksplat[
       only?: ArrayOf[Symbol],
@@ -23,26 +20,16 @@ class ReeDao::Agg
     ],
     Optblock => ArrayOf[Any]
   )
-  def call(dao = nil, ids_or_scope, **opts, &block)
+  def call(dao, ids_or_scope, **opts, &block)
     scope = if ids_or_scope.is_a?(Array) && ids_or_scope.any? { _1.is_a?(Integer) }
-      raise ArgumentError.new("Dao should be provided") if dao.nil?
       return [] if ids_or_scope.empty?
-
       dao.where(id: ids_or_scope)
     elsif ids_or_scope.is_a?(Integer)
-      raise ArgumentError.new("Dao should be provided") if dao.nil?
-
       dao.where(id: ids_or_scope)
     else
       ids_or_scope
     end
 
-    if dao
-      dao_name = dao.first_source_table
-    else
-      dao_name = underscore(demodulize(scope.first.class.name)).to_sym
-    end
-
     list = scope.is_a?(Sequel::Dataset) ? scope.all : scope
 
     if opts[:to_dto]
@@ -51,7 +38,7 @@ class ReeDao::Agg
       end
     end
 
-    load_associations(dao_name, list, **opts, &block) if block_given?
+    load_associations(dao.unfiltered, list, **opts, &block) if block_given?
 
     if ids_or_scope.is_a?(Array)
       list.sort_by { ids_or_scope.index(_1.id) }
@@ -62,7 +49,7 @@ class ReeDao::Agg
 
   private
 
-  def load_associations(dao_name, list, **opts, &block)
+  def load_associations(dao, list, **opts, &block)
     return if list.empty?
 
     local_vars = block.binding.eval(<<-CODE, __FILE__, __LINE__ + 1)
@@ -72,10 +59,9 @@ class ReeDao::Agg
 
     agg_caller = block.binding.eval("self")
 
-    associations = Associations.new(agg_caller, list, local_vars, dao_name, **opts).instance_exec(list, &block)
-    dao = find_dao(dao_name, agg_caller)
+    associations = Associations.new(agg_caller, list, local_vars, dao, **opts).instance_exec(list, &block)
 
-    if dao_in_transaction?(dao) || ReeDao.load_sync_associations_enabled?
+    if dao.db.in_transaction? || ReeDao.load_sync_associations_enabled?
       associations
     else
       associations[:association_threads].map do |association, assoc_type, assoc_name, opts, block|

data/lib/ree_lib/packages/ree_dao/schemas/ree_dao/functions/agg.schema.json

@@ -16,8 +16,8 @@
       "args": [
         {
           "arg": "dao",
-          "arg_type": "opt",
-          "type": "Nilor[PackageName::DaoName::Dao: \"SELECT * FROM `table`\"]"
+          "arg_type": "req",
+          "type": "PackageName::DaoName::Dao: \"SELECT * FROM `table`\""
         },
         {
           "arg": "ids_or_scope",
@@ -38,21 +38,6 @@
     }
   ],
   "links": [
-    {
-      "target": "demodulize",
-      "package_name": "ree_string",
-      "as": "demodulize",
-      "imports": [
 
-      ]
-    },
-    {
-      "target": "underscore",
-      "package_name": "ree_string",
-      "as": "underscore",
-      "imports": [
-
-      ]
-    }
   ]
 }

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

@@ -2,7 +2,7 @@
 require 'faker'
 require 'benchmark'
 
-RSpec.describe :agg do
+RSpec.xdescribe :agg do
   link :agg, from: :ree_dao
   link :build_pg_connection, from: :ree_dao
 
@@ -115,7 +115,7 @@ RSpec.describe :agg do
 
     aggregate :agg_users_benchmark do
       link :users, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :user_passports, from: :ree_dao_agg_test
       link :books, from: :ree_dao_agg_test
       link :movies, from: :ree_dao_agg_test
@@ -151,7 +151,7 @@ RSpec.describe :agg do
 
     fn :users_sync_fetcher do
       link :users, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :user_passports, from: :ree_dao_agg_test
       link :books, from: :ree_dao_agg_test
       link :movies, from: :ree_dao_agg_test
@@ -183,7 +183,7 @@ RSpec.describe :agg do
       return [] if list.empty?
 
       if include.include?(:organization)
-        one_to_one(list, organizations.order(:id))
+        one_to_one(list, organizations_dao.order(:id))
       end
 
       if include.include?(:books)
@@ -233,7 +233,7 @@ RSpec.describe :agg do
   let(:agg_users) { ReeDaoAggTest::AggUsersBenchmark.new }
   let(:users_sync_fetcher) { ReeDaoAggTest::UsersSyncFetcher.new }
 
-  let(:organizations) { ReeDaoAggTest::Organizations.new }
+  let(:organizations) { ReeDaoAggTest::OrganizationsDao.new }
   let(:users) { ReeDaoAggTest::Users.new }
   let(:user_passports) { ReeDaoAggTest::UserPassports.new }
   let(:books) { ReeDaoAggTest::Books.new }

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

@@ -18,7 +18,7 @@ RSpec.describe :agg do
     connection.drop_table(:user_passports, cascade: true) if connection.table_exists?(:user_passports)
     connection.drop_table(:books, cascade: true) if connection.table_exists?(:books)
     connection.drop_table(:chapters, cascade: true) if connection.table_exists?(:chapters)
-    connection.drop_table(:authors, cascade: true) if connection.table_exists?(:authors)
+    connection.drop_table(:avtorki, cascade: true) if connection.table_exists?(:avtorki)
     connection.drop_table(:reviews, cascade: true) if connection.table_exists?(:reviews)
     connection.drop_table(:review_authors, cascade: true) if connection.table_exists?(:review_authors)
 
@@ -71,7 +71,7 @@ RSpec.describe :agg do
       column :name, 'varchar(256)'
     end
 
-    connection.create_table :authors do
+    connection.create_table :avtorki do
       primary_key :id
 
       foreign_key :book_id, :books, null: false, on_delete: :cascade
@@ -88,7 +88,7 @@ RSpec.describe :agg do
 
     aggregate :agg_users do
       link :users, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :user_passports, from: :ree_dao_agg_test
       link :books, from: :ree_dao_agg_test
       link :chapters, from: :ree_dao_agg_test
@@ -160,7 +160,7 @@ RSpec.describe :agg do
       link :books, from: :ree_dao_agg_test
       link :authors, from: :ree_dao_agg_test
       link :chapters, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :agg, from: :ree_dao
     end
 
@@ -268,7 +268,7 @@ RSpec.describe :agg do
 
     aggregate :agg_users_block_test do
       link :users, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :books, from: :ree_dao_agg_test
       link :agg, from: :ree_dao
     end
@@ -297,7 +297,7 @@ RSpec.describe :agg do
 
     aggregate :agg_users_scope_method_test do
       link :users, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :books, from: :ree_dao_agg_test
       link :agg, from: :ree_dao
     end
@@ -345,7 +345,7 @@ RSpec.describe :agg do
 
     aggregate :agg_users_without_dao do
       link :users, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :books, from: :ree_dao_agg_test
       link :agg, from: :ree_dao
     end
@@ -362,7 +362,7 @@ RSpec.describe :agg do
 
     aggregate :agg_users_only_except_keys do
       link :users, from: :ree_dao_agg_test
-      link :organizations, from: :ree_dao_agg_test
+      link :organizations_dao, from: :ree_dao_agg_test
       link :books, from: :ree_dao_agg_test
       link :agg, from: :ree_dao
     end
@@ -384,7 +384,7 @@ RSpec.describe :agg do
   let(:agg_users_with_dto) { ReeDaoAggTest::AggUsersWithDto.new }
   let(:agg_users_only_dataset) { ReeDaoAggTest::AggUsersOnlyDataset.new }
   let(:user_agg_only_except_keys) { ReeDaoAggTest::AggUsersOnlyExceptCase.new }
-  let(:organizations) { ReeDaoAggTest::Organizations.new }
+  let(:organizations) { ReeDaoAggTest::OrganizationsDao.new }
   let(:users) { ReeDaoAggTest::Users.new }
   let(:user_passports) { ReeDaoAggTest::UserPassports.new }
   let(:books) { ReeDaoAggTest::Books.new }

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

@@ -179,7 +179,7 @@ class ReeDaoAggTest::Organization
     id: Nilor[Integer],
     name: String
   )
-  
+
   contract(Array[ReeDaoAggTest::User] => nil)
   def set_users(users)
     @users = users; nil
@@ -354,10 +354,10 @@ class ReeDaoAggTest::Users
   filter :by_name, -> (name) { where(name: name) }
 end
 
-class ReeDaoAggTest::Organizations
+class ReeDaoAggTest::OrganizationsDao
   include ReeDao::DSL
 
-  dao :organizations do
+  dao :organizations_dao do
     link :db
   end
 
@@ -538,7 +538,7 @@ class ReeDaoAggTest::Authors
     link :db
   end
 
-  table :authors
+  table :avtorki
 
   schema ReeDaoAggTest::Author do
     integer :id, null: true

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.68"
+  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.68
+  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