ree_lib 1.0.92 → 1.0.94

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b155d8bd9f9899b0f429bfbc78a4f4e039a8cc171a28ed3a50c4f21595b945c
-  data.tar.gz: d1ef4e988d92c7aea8df9502caee87174f5433d132cca5c75e901876dec6a7b9
+  metadata.gz: 999bb2c56def52960bba5ba42d451d51720732b56c6133c6b2f31138fd5d1b1b
+  data.tar.gz: fcc8978282f0823ad26d8481c6beba74f3ff622306deabb88a93a466c6b9a476
 SHA512:
-  metadata.gz: 373d412300c91bc3c74a746f955143694f7f6691ad461e105190c9d07417b934284b0345cab5819458c3a75894072c0241454af75e9963410d8eefba2f57a5f4
-  data.tar.gz: ecff84e285d84523332aa2c3c66dfbc47f299a63c57a181fa36f4b8bea15913b2fa07ab66b403ba4f7eef6a28cb7e4c87b471710f4d4fca13133c8c00ea1667f
+  metadata.gz: cd5215c19233b1cedd2e817f7dfde0d2d034148fc548e9116f8f67b98f6678a4d7435b14119a4282840e1f20d9e87d59708e0490282b59074b2cfe38ab979c4a
+  data.tar.gz: d3df53d29afbcb3306437ea20e2d4fc6f36d203853737fd1d7359bc31276d744f5ad092dd4283f5ca94cf0cd36e16af1999bddacbbf2f8bd7f5776d9fe103c38

data/Gemfile

@@ -11,4 +11,5 @@ group :test do
   gem 'rspec'
   gem 'bootsnap'
   gem 'webmock'
+  gem 'ruby-prof'
 end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.91)
+    ree_lib (1.0.94)
       bigdecimal (~> 3.1.6)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.14.1)
@@ -73,6 +73,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.1)
+    ruby-prof (1.7.0)
     sequel (5.76.0)
       bigdecimal
     sqlite3 (1.4.4)
@@ -102,6 +103,7 @@ DEPENDENCIES
   roda (~> 3.76.0)
   rollbar (~> 3.5.1)
   rspec
+  ruby-prof
   sqlite3 (~> 1.4.4)
   timecop (~> 0.9.5)
   warden (~> 1.2.9)

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

@@ -44,7 +44,7 @@ module ReeActions
 
         alias_method(:__original_call, :call)
 
-        define_method :call do |user_access, attrs|
+        define_method :call do |user_access, attrs, &proc|
           if self.class.const_defined?(:ActionCaster)
             caster = self.class.const_get(:ActionCaster)
 
@@ -59,7 +59,7 @@ module ReeActions
             end
           end
 
-          __original_call(user_access, attrs)
+          __original_call(user_access, attrs, &proc)
         end
 
         nil

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

@@ -6,25 +6,29 @@ class ReeDao::PgArray < ReeMapper::AbstractWrapper
   contract(
     Any,
     Kwargs[
-      name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Or[Sequel::Postgres::PGArray, String]
   )
-  def db_dump(value, name:, role: nil, fields_filters: [], location: nil)
+  def db_dump(value, role: nil, fields_filters: nil)
     if !value.is_a?(Array)
-      raise ReeMapper::TypeError.new("`#{name}` should be an array, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be an array, got `#{truncate(value.inspect)}`")
     end
 
-    value = value.map.with_index do |el, index|
-      subject.type.db_dump(
-        el,
-        name: "#{name}[#{index}]",
-        role: role,
-        fields_filters: fields_filters + [subject.fields_filter],
-        location: subject.location,
-      )
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value = value.map.with_index do |item, idx|
+      subject.type.db_dump(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.location ||= subject.location
+      e.prepend_field_name(idx.to_s)
+      raise e
     end
 
     if value.empty?
@@ -37,25 +41,29 @@ class ReeDao::PgArray < ReeMapper::AbstractWrapper
   contract(
     Any,
     Kwargs[
-      name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Array
   ).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil, fields_filters: [], location: nil)
+  def db_load(value, role: nil, fields_filters: nil)
     if !value.is_a?(Sequel::Postgres::PGArray)
-      raise ReeMapper::TypeError.new("`#{name}` should be a Sequel::Postgres::PGArray, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a Sequel::Postgres::PGArray, got `#{truncate(value.inspect)}`")
+    end
+
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
     end
 
-    value.map.with_index do |val, index|
-      subject.type.db_load(
-        val,
-        name: "#{name}[#{index}]",
-        role: role,
-        fields_filters: fields_filters + [subject.fields_filter],
-        location: subject.location,
-      )
+    value.map.with_index do |item, idx|
+      subject.type.db_load(item, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.location ||= subject.location
+      e.prepend_field_name(idx.to_s)
+      raise e
     end
   end
 end

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

@@ -6,10 +6,8 @@ class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
   contract(
     Any,
     Kwargs[
-      name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Or[
       Sequel::Postgres::JSONBHash,
       Sequel::Postgres::JSONBArray,
@@ -21,29 +19,34 @@ class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
       Sequel::Postgres::JSONBNull
     ]
   ).throws(ReeMapper::TypeError)
-  def db_dump(value, name:, role: nil, fields_filters: [], location: nil)
-    value = subject.type.db_dump(
-      value,
-      name: name,
-      role: role,
-      fields_filters: fields_filters + [subject.fields_filter],
-      location: subject.location,
-    )
+  def db_dump(value, role: nil, fields_filters: nil)
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    value = begin
+      subject.type.db_dump(value, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.location ||= subject.location
+      raise e
+    end
 
     begin
       Sequel.pg_jsonb_wrap(value)
     rescue Sequel::Error
-      raise ReeMapper::TypeError.new("`#{name}` should be an jsonb primitive, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be an jsonb primitive, got `#{truncate(value.inspect)}`")
     end
   end
 
   contract(
     Any,
     Kwargs[
-      name: String,
       role: Nilor[Symbol, ArrayOf[Symbol]],
-      fields_filters: ArrayOf[ReeMapper::FieldsFilter],
-      location: Nilor[String],
+      fields_filters: Nilor[ArrayOf[ReeMapper::FieldsFilter]],
     ] => Or[
       Hash,
       Array,
@@ -55,7 +58,7 @@ class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
       Rational,
     ]
   ).throws(ReeMapper::TypeError)
-  def db_load(value, name:, role: nil, fields_filters: [], location: nil)
+  def db_load(value, role: nil, fields_filters: nil)
     value = case value
     when Sequel::Postgres::JSONBHash
       ReeObject::ToHash.new.call(value.to_h)
@@ -64,15 +67,22 @@ class ReeDao::PgJsonb < ReeMapper::AbstractWrapper
     when Numeric, String, TrueClass, FalseClass, NilClass
       value
     else
-      raise ReeMapper::TypeError.new("`#{name}` should be a Sequel::Postgres::JSONB, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::TypeError.new("should be a Sequel::Postgres::JSONB, got `#{truncate(value.inspect)}`")
     end
 
-    subject.type.db_load(
-      value,
-      name: name,
-      role: role,
-      fields_filters: fields_filters + [subject.fields_filter],
-      location: subject.location,
-    )
+    if subject.fields_filter
+      fields_filters = if fields_filters
+        fields_filters + [subject.fields_filter]
+      else
+        [subject.fields_filter]
+      end
+    end
+
+    begin
+      subject.type.db_load(value, role:, fields_filters:)
+    rescue ReeMapper::ErrorWithLocation => e
+      e.location ||= subject.location
+      raise e
+    end
   end
-end
+end

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

@@ -8,29 +8,17 @@ class ReeEnum::BaseEnumMapper < ReeMapper::AbstractType
     @enum = enum
   end
 
-  contract(
-    ReeEnum::Value,
-    Kwargs[
-      name: String,
-      location: Nilor[String],
-    ] => Or[Integer, String]
-  )
-  def db_dump(value, name:, location: nil)
+  contract(ReeEnum::Value => Or[Integer, String])
+  def db_dump(value)
     value.mapped_value
   end
 
-  contract(
-    Or[Integer, String],
-    Kwargs[
-      name: String,
-      location: Nilor[String],
-    ] => ReeEnum::Value
-  ).throws(ReeMapper::CoercionError)
-  def db_load(value, name:, location: nil)
+  contract(Or[Integer, String] => ReeEnum::Value).throws(ReeMapper::CoercionError)
+  def db_load(value)
     enum_val = @enum.get_values.by_mapped_value(value)
 
     if !enum_val
-      raise ReeMapper::CoercionError.new("`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::CoercionError.new("should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`")
     end
 
     enum_val
@@ -41,4 +29,4 @@ class ReeEnum::BaseEnumMapper < ReeMapper::AbstractType
   def enum_inspection
     @enum_inspection ||= truncate(@enum.get_values.each.map(&:to_s).inspect)
   end
-end
+end

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

@@ -2,25 +2,13 @@
 require_relative "base_enum_mapper"
 
 class ReeEnum::IntegerValueEnumMapper < ReeEnum::BaseEnumMapper
-  contract(
-    ReeEnum::Value,
-    Kwargs[
-      name: String,
-      location: Nilor[String],
-    ] => Integer
-  )
-  def serialize(value, name:, location: nil)
+  contract(ReeEnum::Value => Integer)
+  def serialize(value)
     value.value
   end
 
-  contract(
-    Any,
-    Kwargs[
-      name: String,
-      location: Nilor[String],
-    ] => ReeEnum::Value
-  ).throws(ReeMapper::CoercionError)
-  def cast(value, name:, location: nil)
+  contract(Any => ReeEnum::Value).throws(ReeMapper::CoercionError)
+  def cast(value)
     enum_value = case value
     when Integer
       @enum.get_values.by_value(value)
@@ -34,9 +22,9 @@ class ReeEnum::IntegerValueEnumMapper < ReeEnum::BaseEnumMapper
     end
 
     if enum_value.nil?
-      raise ReeMapper::CoercionError.new("`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::CoercionError.new("should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`")
     end
 
     enum_value
   end
-end
+end

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

@@ -2,25 +2,13 @@
 require_relative "base_enum_mapper"
 
 class ReeEnum::StringValueEnumMapper < ReeEnum::BaseEnumMapper
-  contract(
-    ReeEnum::Value,
-    Kwargs[
-      name: String,
-      location: Nilor[String],
-    ] => String
-  )
-  def serialize(value, name:, location: nil)
+  contract(ReeEnum::Value => String)
+  def serialize(value)
     value.value
   end
 
-  contract(
-    Any,
-    Kwargs[
-      name: String,
-      location: Nilor[String],
-    ] => ReeEnum::Value
-  ).throws(ReeMapper::CoercionError)
-  def cast(value, name:, location: nil)
+  contract(Any => ReeEnum::Value).throws(ReeMapper::CoercionError)
+  def cast(value)
     enum_value = case value
     when String
       @enum.get_values.by_value(value)
@@ -29,9 +17,9 @@ class ReeEnum::StringValueEnumMapper < ReeEnum::BaseEnumMapper
     end
 
     if enum_value.nil?
-      raise ReeMapper::CoercionError.new("`#{name}` should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`", location)
+      raise ReeMapper::CoercionError.new("should be one of #{enum_inspection}, got `#{truncate(value.inspect)}`")
     end
 
     enum_value
   end
-end
+end

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

@@ -1,25 +1,58 @@
 # frozen_string_literal: true
 
 class ReeMapper::ErrorWithLocation < ReeMapper::Error
-  attr_reader :location
+  attr_accessor :location
 
-  def initialize(message, location = nil)
-    if message.is_a?(String) && location && ENV["RUBY_ENV"] == "test"
-      message = "#{message}, located at #{location}"
-    end
-
-    super(message)
+  contract(String, String, ArrayOf[String]  => Any)
+  def initialize(message, location = nil, field_name_parts = [])
+    @message = message
     @location = location
+    @field_name_parts = field_name_parts
   end
 
-  def full_message(...)
-    msg = super
-    return msg if location.nil?
+  contract(String => nil)
+  def prepend_field_name(part)
+    @field_name_parts.unshift part
+    nil
+  end
+
+  contract(None => Nilor[String])
+  def field_name
+    @field_name_parts.reduce { "#{_1}[#{_2}]" }
+  end
+
+  if ENV["RUBY_ENV"] == "test"
+
+    contract(None => String)
+    def message
+      msg = @message
+
+      if location
+        msg = "#{msg}, located at #{location}"
+      end
+
+      return msg if @field_name_parts.empty?
 
-    idx = msg.index(/\).*\n/)
-    return msg if idx.nil?
-    return msg if ENV["RUBY_ENV"] == "test"
+      "`#{field_name}` #{msg}"
+    end
+
+  else
+
+    def message
+      return @message if @field_name_parts.empty?
+
+      "`#{field_name}` #{@message}"
+    end
+
+    def full_message(...)
+      msg = super
+      return msg if location.nil?
+
+      last_sym_idx = msg.index(/\).*\n/)
+      return msg if last_sym_idx.nil?
+
+      msg.insert(last_sym_idx + 1, ", located at #{location}")
+    end
 
-    msg.insert(idx + 1, ", located at #{location}")
   end
 end

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

@@ -33,7 +33,7 @@ class ReeMapper::Field
     @roles    = Array(role)
     @default  = default
 
-    @fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
+    @fields_filter = ReeMapper::FieldsFilter.build(only, except)
 
     @name_as_str               = @name.to_s
     @name_as_instance_var_name = :"@#{@name}"

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

@@ -55,35 +55,26 @@ class ReeMapper::FieldsFilter
     attr_reader :fields
   end
 
-  class NoneStrategy
-    def self.allow?(field)
-      true
-    end
-  end
-
-  def self.empty_filter
-    @empty_filter ||= new(NoneStrategy, {}).freeze
-  end
-
-  contract Nilor[ReeMapper::FilterFieldsContract], Nilor[ReeMapper::FilterFieldsContract] => Any
-  def self.build(only:, except:)
-    return empty_filter if only.nil? && except.nil?
-
+  contract(
+    Nilor[ReeMapper::FilterFieldsContract],
+    Nilor[ReeMapper::FilterFieldsContract] => Nilor[ReeMapper::FieldsFilter]
+  )
+  def self.build(only, except)
     strategy = if !only.nil?
       OnlyStrategy.new(only, except)
     elsif !except.nil?
       ExceptStrategy.new(except)
     else
-      NoneStrategy
+      return nil
     end
 
     nested_fields_filters = {}
-    
+
     only = only&.select { _1.is_a? Hash }&.reduce(&:merge)
     except = except&.select { _1.is_a? Hash }&.reduce(&:merge)
 
-    only&.each { nested_fields_filters[_1] = build(only: _2, except: except&.dig(_1)) }
-    except&.each { nested_fields_filters[_1] ||= build(only: nil, except: _2) }
+    only&.each { nested_fields_filters[_1] = build(_2, except&.dig(_1)) }
+    except&.each { nested_fields_filters[_1] ||= build(nil, _2) }
 
     new(strategy, nested_fields_filters)
   end
@@ -98,9 +89,9 @@ class ReeMapper::FieldsFilter
   end
 
   def filter_for(field)
-    nested_fields_filters.fetch(field, self.class.empty_filter)
+    nested_fields_filters[field]
   end
 
   private
   attr_reader :strategy, :nested_fields_filters
-end
+end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 class ReeMapper::Mapper
-  EMPTY_ARY = [].freeze
-
   contract(
     ArrayOf[ReeMapper::MapperStrategy],
     Nilor[ReeMapper::AbstractType, ReeMapper::AbstractWrapper] => self
@@ -25,77 +23,67 @@ class ReeMapper::Mapper
 
         if type
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: EMPTY_ARY, location: nil)
+            def #{method}(obj, role: nil, only: nil, except: nil, fields_filters: nil)
               #{
                 if type.is_a?(ReeMapper::AbstractWrapper)
-                  "@type.#{method}(obj, name: name, role: role, fields_filters: fields_filters, location: location)"
+                  "@type.#{method}(obj, role:, fields_filters:)"
                 else
-                  "@type.#{method}(obj, name: name, location: location)"
+                  "@type.#{method}(obj)"
                 end
               }
             end
           RUBY
         else
           class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{method}(obj, name: nil, role: nil, only: nil, except: nil, fields_filters: EMPTY_ARY, location: nil)
-              if only && !ReeMapper::FilterFieldsContract.valid?(only)
-                raise ReeMapper::ArgumentError, "Invalid `only` format"
-              end
-
-              if except && !ReeMapper::FilterFieldsContract.valid?(except)
-                raise ReeMapper::ArgumentError, "Invalid `except` format"
-              end
+            def #{method}(obj, role: nil, only: nil, except: nil, fields_filters: nil)
+              user_fields_filter = ReeMapper::FieldsFilter.build(only, except)
 
-              user_fields_filter = ReeMapper::FieldsFilter.build(only: only, except: except)
-
-              @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
-                field_fields_filters = if user_fields_filter == ReeMapper::FieldsFilter::NoneStrategy
-                  fields_filters
+              if !user_fields_filter.nil?
+                fields_filters = if fields_filters.nil?
+                  [user_fields_filter]
                 else
                   fields_filters + [user_fields_filter]
                 end
+              end
 
-                next unless field_fields_filters.all? { _1.allow? field.name }
+              @fields.each_with_object(@#{method}_strategy.build_object) do |(_, field), acc|
+                next unless fields_filters.nil? || fields_filters.all? { _1.allow? field.name }
                 next unless field.has_role?(role)
 
-                is_with_value = @#{method}_strategy.has_value?(obj, field)
-                is_optional = field.optional || @#{method}_strategy.always_optional
-
-                if !is_with_value && !is_optional
-                  raise ReeMapper::TypeError.new(
-                    "Missing required field `\#{field.from_as_str}` for `\#{name || 'root'}`", 
-                    field.location
-                  )
-                end
-
-                next if !is_with_value && !field.has_default?
-
-                value = if is_with_value
+                value = if @#{method}_strategy.has_value?(obj, field)
                   @#{method}_strategy.get_value(obj, field)
                 else
+                  if !field.optional && !@#{method}_strategy.always_optional
+                    raise ReeMapper::TypeError.new(
+                      "is missing required field",
+                      field.location,
+                      [field.from_as_str]
+                    )
+                  end
+
+                  next unless field.has_default?
+
                   field.default
                 end
 
-                unless value.nil? && field.null
-                  nested_name = name ? "\#{name}[\#{field.name_as_str}]" : field.name_as_str
+                if !value.nil? || !field.null
+                  nested_fields_filters = fields_filters&.filter_map { _1.filter_for(field.name) }
 
-                  nested_fields_filters = if field_fields_filters.empty?
-                    field_fields_filters
-                  else
-                    field_fields_filters.map { _1.filter_for(field.name) }
+                  if field.fields_filter
+                    nested_fields_filters = if nested_fields_filters
+                      nested_fields_filters + [field.fields_filter]
+                    else
+                      [field.fields_filter]
+                    end
                   end
 
-                  if field.fields_filter != ReeMapper::FieldsFilter::NoneStrategy
-                    nested_fields_filters += [field.fields_filter]
+                  value = begin
+                    field.type.#{method}(value, role:, fields_filters: nested_fields_filters)
+                  rescue ReeMapper::ErrorWithLocation => e
+                    e.prepend_field_name field.name_as_str
+                    e.location ||= field.location
+                    raise e
                   end
-
-                  value = field.type.#{method}(
-                    value,
-                    name: nested_name,
-                    role: role,
-                    fields_filters: nested_fields_filters,
-                    location: field.location,
-                  )
                 end
 
                 @#{method}_strategy.assign_value(acc, field, value)

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

@@ -2,7 +2,7 @@ class ReeMapper::AbstractType
   private
 
   def truncate(str, limit = 180)
-    @trancator ||= ReeString::Truncate.new
-    @trancator.call(str, limit)
+    @truncate ||= ReeString::Truncate.new
+    @truncate.(str, limit)
   end
 end