foobara 0.0.101 → 0.0.103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72936127f925aeecd5c813edff203628a88e65408a1fb4f9d0b68657d664fd1b
-  data.tar.gz: aec6b40247986426ff94202cbc00057b37476e5e95652f8ac2d58c99647b50bf
+  metadata.gz: 506c445dbdf8c1bd6d1a2db990e317e3a8893754aea2f1d607aa03dccc516749
+  data.tar.gz: e7170ed694b6bc096391a98e724080bfeab36b3b2528bd49ad105a1e1f3453fe
 SHA512:
-  metadata.gz: adba03dad2ca90ca4202cf6e67e67c335748958f856d4fa75ef2bc3545b5e31a0acf5ef84002312252fd7cc3e113daf1fb5ec54308843902c1418a39ad4ea33b
-  data.tar.gz: 0bee2126b8262f17b673c0f6b0158cdd37b80bb27ba4c42d9a09abf584a0aa900bfbc55dfd1e58cc261aa6c98898e7f4c2bef2a138f51a0f754fe85a9c8ca129
+  metadata.gz: 5f5350c1728e42deb835e3d4d32b9ffcc7e5ae56cb4054a0738b9932c82d87d0fb6c608954f5bc0f30b55ecb7f688e6da46af364a80f40ed07c152f0c9ae6e50
+  data.tar.gz: fbadbfb1a7a086101a2b0e02fefb06e15ad12954c816566fadd6b17728a0b27db140d3e737617ace5fd3e80cb56b57752e50caac8d7063ac61a22b13bc44a48c

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# [0.0.103] - 2025-04-17
+
+- Fix bugs in complicated entity query calls involving mixtures of models/records/primary keys/attributes
+- Fix bugs re: .construct_associations/_deep_associations resulting in terribad performance in some projects
+- Allow lambdas to be used as allowed rules
+- Improve .delegate_attribute interface
+
+# [0.0.102] - 2025-04-13
+
+- Extract ThreadParent to its own repository/gem
+
 # [0.0.101] - 2025-04-12
 
 - Add Entity#update

data/projects/builtin_types/src/attributes/transformers/remove_unexpected_attributes.rb

@@ -1,3 +1,5 @@
+require "inheritable_thread_vars"
+
 module Foobara
   module BuiltinTypes
     module Attributes
@@ -10,7 +12,8 @@ module Foobara
           end
 
           def applicable?(hash)
-            Thread.foobara_var_get(:foobara_ignore_unexpected_attributes) && unexpected_attributes(hash).any?
+            Thread.inheritable_thread_local_var_get(:foobara_ignore_unexpected_attributes) &&
+              unexpected_attributes(hash).any?
           end
 
           def transform(hash)

data/projects/command/src/command_pattern_implementation/concerns/transactions.rb

@@ -35,6 +35,10 @@ module Foobara
               entity_classes += Entity.construct_associations(
                 result_type
               ).values.uniq.map(&:target_class)
+
+              if result_type.extends?(BuiltinTypes[:entity])
+                entity_classes << result_type.target_class
+              end
             end
 
             entity_classes += entity_classes.uniq.map do |entity_class|

data/projects/command/src/transformed_command.rb

@@ -556,9 +556,7 @@ module Foobara
 
       if rule
         command.after_load_records do |command:, **|
-          # NOTE: apparently no way to convert a lambda to a proc but lambda's won't work here...
-          # TODO: raise exception here if rule.lambda? is true, if this starts becoming a common error
-          is_allowed = instance_eval(&rule)
+          is_allowed = instance_exec(&rule)
 
           unless is_allowed
             explanation = allowed_rule.explanation
@@ -568,7 +566,18 @@ module Foobara
             end
 
             if explanation.nil?
-              explanation = allowed_rule.block.source || "No explanation."
+              source = begin
+                allowed_rule.block.source
+              rescue MethodSource::SourceNotFoundError
+                # This path is hit if the way the source code is extracted
+                # doesn't result in valid Ruby, for example, as part of a hash such as:
+                # allowed_rule: -> () { whatever?(something) },
+                # :nocov:
+                allowed_rule.block.source_location.join(":")
+                # :nocov:
+              end
+
+              explanation = source || "No explanation."
             end
 
             error = CommandConnector::NotAllowedError.new(rule_symbol: rule.symbol, explanation:)

data/projects/command_connectors/src/command_connector.rb

@@ -374,7 +374,7 @@ module Foobara
       request_command = request.command
 
       request_command.after_load_records do |command:, **|
-        authenticated_user = request.instance_eval(&authenticator)
+        authenticated_user = request.instance_exec(&authenticator)
 
         request_command.authenticated_user = authenticated_user
 

data/projects/detached_entity/src/concerns/associations.rb

@@ -154,8 +154,13 @@ module Foobara
           def construct_associations(
             type = attributes_type,
             path = DataPath.new,
-            result = {}
+            result = {},
+            initial: true
           )
+            if initial && type.extends?(BuiltinTypes[:detached_entity])
+              return construct_associations(type.element_types, path, result, initial: false)
+            end
+
             remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
 
             if type.extends?(BuiltinTypes[:entity])
@@ -171,7 +176,7 @@ module Foobara
               end
 
               element_types&.each&.with_index do |element_type, index|
-                construct_associations(element_type, path.append(index), result)
+                construct_associations(element_type, path.append(index), result, initial: false)
               end
             elsif type.extends?(BuiltinTypes[:array])
               # TODO: what to do about an associative array type?? Unclear how to make a key from that...
@@ -179,7 +184,7 @@ module Foobara
               element_type = type.element_type
 
               if element_type && (!remove_sensitive || !element_type.sensitive?)
-                construct_associations(element_type, path.append(:"#"), result)
+                construct_associations(element_type, path.append(:"#"), result, initial: false)
               end
             elsif type.extends?(BuiltinTypes[:attributes]) # TODO: matches attributes itself instead of only subtypes
               type.element_types.each_pair do |attribute_name, element_type|
@@ -187,7 +192,7 @@ module Foobara
                   next
                 end
 
-                construct_associations(element_type, path.append(attribute_name), result)
+                construct_associations(element_type, path.append(attribute_name), result, initial: false)
               end
             elsif type.extends?(BuiltinTypes[:model])
               target_class = type.target_class
@@ -196,7 +201,7 @@ module Foobara
               attributes_type = target_class.send(method)
 
               if !remove_sensitive || !attributes_type.sensitive?
-                construct_associations(attributes_type, path, result)
+                construct_associations(attributes_type, path, result, initial: false)
               end
             elsif type.extends?(BuiltinTypes[:associative_array])
               # not going to bother testing this for now

data/projects/foobara/lib/foobara/all.rb

@@ -9,9 +9,8 @@ module Foobara
 
   module Monorepo
     # could be independent projects
-    projects "delegate",
+    projects "delegate", # Let's just kill delegate
              "concerns",
-             "thread_parent",
              "weak_object_set",
              "enumerated",
              "callback",

data/projects/model/src/concerns/types.rb

@@ -173,11 +173,16 @@ module Foobara
 
           def delegate_attributes(delegates)
             delegates.each_pair do |attribute_name, delegate_info|
-              delegate_attribute(attribute_name, delegate_info[:data_path], writer: delegate_info[:writer])
+              data_path = DataPath.for(delegate_info[:data_path])
+              delegate_attribute(attribute_name, data_path, writer: delegate_info[:writer])
             end
           end
 
           def delegate_attribute(attribute_name, data_path, writer: false)
+            if data_path.is_a?(::Symbol) || data_path.is_a?(::String)
+              data_path = [data_path, attribute_name]
+            end
+
             data_path = DataPath.for(data_path)
 
             delegate_manifest = { data_path: data_path.to_s }

data/projects/model/src/model.rb

@@ -1,3 +1,5 @@
+require "inheritable_thread_vars"
+
 module Foobara
   # TODO: either make this an abstract base class of ValueModel and Entity or rename it to ValueModel
   # and have Entity inherit from it...
@@ -180,7 +182,7 @@ module Foobara
       end
 
       if options[:ignore_unexpected_attributes]
-        Thread.foobara_with_var(:foobara_ignore_unexpected_attributes, true) do
+        Thread.with_inheritable_thread_local_var(:foobara_ignore_unexpected_attributes, true) do
           initialize(attributes, options.except(:ignore_unexpected_attributes))
           return
         end
@@ -195,7 +197,7 @@ module Foobara
           # :nocov:
         end
       else
-        if Thread.foobara_var_get(:foobara_ignore_unexpected_attributes)
+        if Thread.inheritable_thread_local_var_get(:foobara_ignore_unexpected_attributes)
           outcome = attributes_type.process_value(attributes)
 
           if outcome.success?

data/projects/persistence/src/entity_attributes_crud_driver.rb

@@ -1,4 +1,5 @@
 module Foobara
+  # Might be best to rename this to CrudDrivers or CrudDriver instead of Persistence?
   module Persistence
     class EntityAttributesCrudDriver
       attr_accessor :raw_connection, :tables
@@ -156,29 +157,39 @@ module Foobara
 
         def matches_attributes_filter?(attributes, attributes_filter)
           attributes_filter.all? do |attribute_name_or_path, value|
-            type = nil
+            value = normalize_attribute_filter_value(value)
 
             if attribute_name_or_path.is_a?(::Array)
               values = DataPath.values_at(attribute_name_or_path, attributes)
 
-              if values.include?(value)
-                true
-              else
-                type ||= entity_class.model_type.type_at_path(attribute_name_or_path)
-                if type.extends?(:detached_entity)
-                  values.any? do |v|
-                    value.primary_key == v
-                  end
-                end
+              values.any? do |attribute_value|
+                normalize_attribute_filter_value(attribute_value) == value
               end
-            elsif attributes[attribute_name_or_path] == value
-              true
             else
-              type ||= entity_class.model_type.type_at_path(attribute_name_or_path)
-              if type.extends?(:detached_entity)
-                value.primary_key == attributes[attribute_name_or_path]
-              end
+              attribute_value = attributes[attribute_name_or_path]
+              normalize_attribute_filter_value(attribute_value) == value
+            end
+          end
+        end
+
+        def normalize_attribute_filter_value(value)
+          case value
+          when ::Array
+            value.map { |v| normalize_attribute_filter_value(v) }
+          when ::Hash
+            value.to_h do |k, v|
+              [normalize_attribute_filter_value(k), normalize_attribute_filter_value(v)]
+            end
+          when DetachedEntity
+            if value.persisted?
+              normalize_attribute_filter_value(value.primary_key)
+            else
+              value
             end
+          when Model
+            normalize_attribute_filter_value(value.attributes)
+          else
+            value
           end
         end
 

data/projects/persistence/src/entity_base/transaction_table.rb

@@ -258,8 +258,6 @@ module Foobara
             [attribute_name,  element_types[attribute_name].process_value!(value)]
           end
 
-          attributes_filter = to_persistable(attributes_filter, false)
-
           tracked_records.each do |record|
             next if hard_deleted?(record)
 

data/projects/persistence/src/entity_base.rb

@@ -1,3 +1,5 @@
+require "inheritable_thread_vars"
+
 module Foobara
   module Persistence
     class EntityBase
@@ -43,11 +45,11 @@ module Foobara
       end
 
       def current_transaction
-        Thread.foobara_var_get(transaction_key)
+        Thread.inheritable_thread_local_var_get(transaction_key)
       end
 
       def set_current_transaction(transaction)
-        Thread.foobara_var_set(transaction_key, transaction)
+        Thread.inheritable_thread_local_var_set(transaction_key, transaction)
       end
 
       VALID_MODES = [:use_existing, :open_nested, :open_new, nil].freeze

data/projects/type_declarations/src/type_declarations.rb

@@ -1,3 +1,5 @@
+require "inheritable_thread_vars"
+
 module Foobara
   require_project_file("type_declarations", "type_builder")
   require_project_file("type_declarations", "error_extension")
@@ -91,7 +93,7 @@ module Foobara
       end
 
       def foobara_manifest_context
-        Thread.foobara_var_get("foobara_manifest_context")
+        Thread.inheritable_thread_local_var_get("foobara_manifest_context")
       end
 
       allowed_context_keys = %i[detached to_include mode remove_sensitive]
@@ -117,10 +119,10 @@ module Foobara
         old_context = foobara_manifest_context
         begin
           new_context = (old_context || {}).merge(context)
-          Thread.foobara_var_set("foobara_manifest_context", new_context)
+          Thread.inheritable_thread_local_var_set("foobara_manifest_context", new_context)
           yield
         ensure
-          Thread.foobara_var_set("foobara_manifest_context", old_context)
+          Thread.inheritable_thread_local_var_set("foobara_manifest_context", old_context)
         end
       end
     end

data/projects/types/src/type.rb

@@ -20,8 +20,6 @@ module Foobara
                     :validators,
                     :element_processors,
                     :structure_count,
-                    :element_types,
-                    :element_type,
                     :is_builtin,
                     :raw_declaration_data,
                     :name,
@@ -33,6 +31,9 @@ module Foobara
 
       attr_reader :type_symbol
 
+      attr_writer :element_types,
+                  :element_type
+
       def initialize(
         *,
         target_classes:,
@@ -83,6 +84,14 @@ module Foobara
         sensitive_exposed
       end
 
+      def element_type
+        @element_type || base_type&.element_type
+      end
+
+      def element_types
+        @element_types || base_type&.element_types
+      end
+
       def has_sensitive_types?
         return true if sensitive?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.101
+  version: 0.0.103
 platform: ruby
 authors:
 - Miles Georgi
@@ -51,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.11
+- !ruby/object:Gem::Dependency
+  name: inheritable-thread-vars
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 description: A command-centric and discoverable software framework with a focus on
   domain concepts and abstracting away integration code
 email:
@@ -364,8 +378,6 @@ files:
 - projects/state_machine/src/sugar.rb
 - projects/state_machine/src/transition_log.rb
 - projects/state_machine/src/validations.rb
-- projects/thread_parent/lib/foobara/thread_parent.rb
-- projects/thread_parent/src/thread_parent.rb
 - projects/type_declarations/lib/foobara/type_declarations.rb
 - projects/type_declarations/src/attributes.rb
 - projects/type_declarations/src/attributes_transformers/only.rb
@@ -471,7 +483,6 @@ require_paths:
 - "./projects/namespace/lib"
 - "./projects/persistence/lib"
 - "./projects/state_machine/lib"
-- "./projects/thread_parent/lib"
 - "./projects/type_declarations/lib"
 - "./projects/types/lib"
 - "./projects/value/lib"

data/projects/thread_parent/lib/foobara/thread_parent.rb

@@ -1 +0,0 @@
-module Foobara::ThreadParent; end

data/projects/thread_parent/src/thread_parent.rb

@@ -1,53 +0,0 @@
-module Foobara
-  module ThreadParent
-    module ThreadClassExtensions
-      def new(...)
-        super.tap { |thread| thread.instance_variable_set("@foobara_parent", Thread.current) }
-      end
-    end
-  end
-end
-
-class Thread
-  class << self
-    prepend(Foobara::ThreadParent::ThreadClassExtensions)
-
-    def foobara_var_get(...)
-      Thread.current.foobara_var_get(...)
-    end
-
-    def foobara_var_set(...)
-      Thread.current.foobara_var_set(...)
-    end
-
-    def foobara_with_var(...)
-      Thread.current.foobara_with_var(...)
-    end
-  end
-
-  attr_reader :foobara_parent
-
-  # NOTE: because there's not a way to unset a thread variable, storing nil is used as deletion.
-  # this means that a thread local variable with nil can't have any semantic meaning and should be
-  # treated the same as if #thread_variable? had returned false.
-  def foobara_var_get(...)
-    value = thread_variable_get(...)
-
-    value.nil? ? foobara_parent&.foobara_var_get(...) : value
-  end
-
-  def foobara_var_set(...)
-    thread_variable_set(...)
-  end
-
-  def foobara_with_var(key, value, &block)
-    old_value = foobara_var_get(key)
-
-    begin
-      foobara_var_set(key, value)
-      block.call
-    ensure
-      foobara_var_set(key, old_value)
-    end
-  end
-end