foobara 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3eea1befe835410f5c6ecc372c5db94e3641f90711a773b0a7685a18afe677f
-  data.tar.gz: 7fe5e33084023a8d475e0fe491520a179d9123b5109c0ebc2ad52ed5643752bd
+  metadata.gz: 497323362ef9b9bcf4a7d17cb9400b84701e73dc464f3ff318e6a52b6ee3bbf6
+  data.tar.gz: ee7bc81ea47e850b90e569c4295bd914832c3604277790edd6db153e143515a6
 SHA512:
-  metadata.gz: 67bbdfab3b295bbe38f39d978f2855a239092f9feba4a417bbb853759dae9527dcbd0ba3a34647925f2b90fc15693c03ddb56a5d5e9247678c22c236deedba2c
-  data.tar.gz: bc09a9a484f9c1e6487a7ce112e33aabb5132b77071f195ed06cafb79895c070ee895be8e3cdd01abf75c4fc4eb54c51dd23d0bd4b22f7d1e0ef3b584c5874d7
+  metadata.gz: acc9a5fed9bdfa6f7c19d74652b6c2bf770a24c17880968dc476289d2231ea51b906c538ee3d10dc65365c74d9d97f9f747ae3c97400789ce30e60babc9ca6b2
+  data.tar.gz: 03225ae2b838efc6816fe072b0f94ea6193552bb1253159aaa749ec471c18d4ea821c399cba711f6f6246cf1c38686d398bb4cd5c6385daebf91014a3ab88436

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# [0.1.8] - 2025-08-25
+
+- Memoize various parts of Type
+- Eliminate DoesNotNeedCastIf* processors
+
+# [0.1.7] - 2025-08-25
+
+- Go back to using :detached_entity for entities that have had sensitive types removed to
+  avoid casting problems with multiple entities with the same name
+- Remove private attributes as if they were sensitive attributes when exposing models
+
 # [0.1.6] - 2025-08-25
 
 - Allow constructing a thunk-like record when removing sensitive values from a thunk

data/projects/callback/src/block/concerns/block_parameter_not_allowed.rb

@@ -3,15 +3,15 @@ module Foobara
     class Block
       module Concerns
         module BlockParameterNotAllowed
+          class BlockParameterNotAllowedError < StandardError; end
+
           private
 
           def validate_original_block!
             super
 
             if takes_block?
-              # :nocov:
-              raise ArgumentError, "#{type} callback is not allowed to accept a block"
-              # :nocov:
+              raise BlockParameterNotAllowedError, "#{type} callback is not allowed to accept a block"
             end
           end
         end

data/projects/callback/src/block/concerns/type.rb

@@ -6,6 +6,8 @@ module Foobara
           include Concern
 
           module ClassMethods
+            # TODO: consider renaming this to symbol? Could be confused with Foobara::Type concept
+            # Returns things like :before, :after, :around, :error to indicate what type of callback it is
             def type
               @type ||= Util.non_full_name_underscore(self)&.gsub(/_block$/, "")&.to_sym
             end

data/projects/callback/src/block.rb

@@ -26,7 +26,9 @@ module Foobara
         validate_original_block!
       end
 
-      foobara_delegate :type, to: :class
+      def type
+        self.class.type
+      end
 
       def call(...)
         to_proc.call(...)
@@ -48,7 +50,7 @@ module Foobara
       end
 
       def takes_block?
-        @takes_block ||= original_block.parameters.last&.first&.==(:block)
+        @takes_block ||= original_block.parameters.last&.first&.==(:block) || false
       end
 
       def has_one_or_zero_positional_args?

data/projects/entity/src/extensions/builtin_types/entity/casters/record_from_closed_transaction.rb

@@ -0,0 +1,26 @@
+require_relative "primary_key"
+
+module Foobara
+  module BuiltinTypes
+    module Entity
+      module Casters
+        class RecordFromClosedTransaction < PrimaryKey
+          def applicable?(value)
+            if value.is_a?(entity_class) && value.persisted?
+              tx = value.class.entity_base.current_transaction
+
+              if tx&.currently_open?
+                # TODO: might be safer/more performant to store the transaction on the record?
+                !value.class.entity_base.current_transaction.tracking?(value)
+              end
+            end
+          end
+
+          def transform(record)
+            super(record.primary_key)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/entity/src/extensions/builtin_types/entity/casters/record_from_current_transaction.rb

@@ -0,0 +1,22 @@
+require_relative "primary_key"
+
+module Foobara
+  module BuiltinTypes
+    module Entity
+      module Casters
+        class RecordFromCurrentTransaction < PrimaryKey
+          def applicable?(value)
+            if value.is_a?(entity_class)
+              tx = entity_class.entity_base.current_transaction
+              !tx&.currently_open? || tx.tracking?(value)
+            end
+          end
+
+          def transform(record)
+            record
+          end
+        end
+      end
+    end
+  end
+end

data/projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/to_type_transformer.rb

@@ -7,12 +7,11 @@ module Foobara
             super.tap do |outcome|
               if outcome.success?
                 type = outcome.result
+                type.cast_even_if_instance_of_target_type = true
                 entity_class = type.target_class
 
                 unless entity_class.can_be_created_through_casting?
-                  type.casters = type.casters.reject do |caster|
-                    caster.is_a?(Foobara::BuiltinTypes::Entity::Casters::Hash)
-                  end
+                  type.remove_caster_instances_of(Foobara::BuiltinTypes::Entity::Casters::Hash)
                 end
               end
             end

data/projects/entity/src/sensitive_type_removers/entity.rb

@@ -7,14 +7,13 @@ module Foobara
 
           if strict_type_declaration != new_type_declaration
             if new_type_declaration[:type] == :entity
-              if Namespace.current.foobara_root_namespace == Namespace.global.foobara_root_namespace
-                # Nervous about creating two entities with the same name in the same namespace
-                # So going to create a detached entity instead
-                new_type_declaration[:type] = :detached_entity
+              # It's important that we don't create another entity with different attributes
+              # or various things like crud drivers or type transformers can become confused.
+              # So we will create it as a detached_entity instead.
+              new_type_declaration[:type] = :detached_entity
 
-                if new_type_declaration[:model_base_class] == "Foobara::Entity"
-                  new_type_declaration[:model_base_class] = "Foobara::DetachedEntity"
-                end
+              if new_type_declaration[:model_base_class] == "Foobara::Entity"
+                new_type_declaration[:model_base_class] = "Foobara::DetachedEntity"
               end
             end
           end

data/projects/entity/src/sensitive_value_removers/entity.rb

@@ -8,7 +8,7 @@ module Foobara
           elsif record.persisted?
             # We will assume that we do not need to clean up the primary key itself as
             # we will assume we don't allow sensitive primary keys for now.
-            thunkish = to_type.target_class.build(record.class.primary_key_attribute => record.primary_key)
+            thunkish = to_type.target_class.send(build_method, record.class.primary_key_attribute => record.primary_key)
             thunkish.skip_validations = true
             thunkish.mutable = false
             thunkish
@@ -20,7 +20,14 @@ module Foobara
         end
 
         def build_method
-          :build
+          if to_type.extends?(BuiltinTypes[:entity])
+            # TODO: figure out a way to test this path
+            # :nocov:
+            :build
+            # :nocov:
+          else
+            :new
+          end
         end
       end
     end

data/projects/types/src/type.rb

@@ -15,20 +15,21 @@ module Foobara
       end
 
       attr_accessor :base_type,
-                    :casters,
-                    :transformers,
-                    :validators,
-                    :element_processors,
                     :structure_count,
                     :is_builtin,
                     :name,
-                    :target_classes,
                     :description,
                     :sensitive,
-                    :sensitive_exposed,
-                    :processor_classes_requiring_type
+                    :sensitive_exposed
 
-      attr_reader :type_symbol
+      attr_reader :type_symbol,
+                  :casters,
+                  :transformers,
+                  :validators,
+                  :target_classes,
+                  :processor_classes_requiring_type,
+                  :element_processors,
+                  :cast_even_if_instance_of_target_type
 
       attr_writer :element_types,
                   :element_type
@@ -116,6 +117,12 @@ module Foobara
       def has_sensitive_types?
         return true if sensitive?
 
+        # TODO: this is a hack... come up with a better/separate way to detect types with private attributes
+        if declaration_data.is_a?(::Hash)
+          private = declaration_data[:private]
+          return true if private.is_a?(::Array) && !private.empty?
+        end
+
         if element_type
           return true if element_type.has_sensitive_types?
         end
@@ -162,9 +169,34 @@ module Foobara
           category.delete_if { |p| p.symbol == symbol }
 
           category << processor
+          clear_caches
+        end
+      end
+
+      def clear_caches
+        [
+          :@value_validator,
+          :@processors,
+          :@value_caster,
+          :@value_transformer,
+          :@element_processor,
+          :@possible_errors,
+          :@processors_without_casters
+        ].each do |instance_variable|
+          if instance_variable_defined?(instance_variable)
+            remove_instance_variable(instance_variable)
+          end
         end
       end
 
+      def remove_caster_instances_of(klass)
+        self.casters = casters.reject do |caster|
+          caster.is_a?(klass)
+        end
+
+        clear_caches
+      end
+
       def remove_processor_by_symbol(symbol)
         [
           casters,
@@ -178,6 +210,7 @@ module Foobara
         end
         supported_processor_classes&.each { |processor_hash| processor_hash.delete(symbol) }
         processor_classes_requiring_type&.delete_if { |p| p.symbol == symbol }
+        clear_caches
       end
 
       def each_processor_class_requiring_type(&block)
@@ -212,6 +245,8 @@ module Foobara
             end
           end
         end
+
+        clear_caches
       end
 
       def target_class
@@ -293,11 +328,52 @@ module Foobara
         base_type&.extends_type?(type)
       end
 
+      def processors=(...)
+        clear_caches
+        super
+      end
+
       def type_symbol=(type_symbol)
         @scoped_path ||= type_symbol.to_s.split("::")
+        clear_caches
         @type_symbol = type_symbol.to_sym
       end
 
+      def cast_even_if_instance_of_target_type=(flag)
+        clear_caches
+        @cast_even_if_instance_of_target_type = flag
+      end
+
+      def casters=(processors)
+        clear_caches
+        @casters = processors
+      end
+
+      def transformers=(processors)
+        clear_caches
+        @transformers = processors
+      end
+
+      def validators=(processors)
+        clear_caches
+        @validators = processors
+      end
+
+      def target_classes=(processors)
+        clear_caches
+        @target_classes = processors
+      end
+
+      def processor_classes_requiring_type=(processors)
+        clear_caches
+        @processor_classes_requiring_type = processors
+      end
+
+      def element_processors=(processors)
+        clear_caches
+        @element_processors = processors
+      end
+
       def full_type_symbol
         return @full_type_symbol if defined?(@full_type_symbol)
 
@@ -307,17 +383,16 @@ module Foobara
       end
 
       def processors
-        [
+        @processors ||= [
           value_caster,
           value_transformer,
           value_validator,
           element_processor
-        ].compact
+        ].compact.sort_by(&:priority)
       end
 
       def value_caster
-        # TODO: figure out what would be needed to successfully memoize this
-        # return @value_caster if defined?(@value_caster)
+        return @value_caster if defined?(@value_caster)
 
         # We make this exception for :duck because it will match any instance of
         # Object but AllowNil will match nil which is also an instance of Object.
@@ -329,16 +404,19 @@ module Foobara
                            true
                          end
 
-        Value::Processor::Casting.new(
-          { cast_to: reference_or_declaration_data },
-          casters:,
-          target_classes:,
-          enforce_unique:
-        )
+        Namespace.use created_in_namespace do
+          @value_caster = Value::Processor::Casting.new(
+            { cast_to: reference_or_declaration_data },
+            casters:,
+            target_classes:,
+            enforce_unique:,
+            cast_even_if_instance_of_target_type:
+          )
+        end
       end
 
       def applicable?(value)
-        value_caster.can_cast?(value)
+        !value_caster.needs_cast?(value) || value_caster.can_cast?(value)
       end
 
       foobara_delegate :needs_cast?, to: :value_caster
@@ -356,24 +434,30 @@ module Foobara
       # method in the instance of the processor as needed. This means it can't really memoize stuff. Should we create
       # an instance of something from the instance of the processor and then ask it questions?? TODO: try this
       def value_transformer
-        if transformers && !transformers.empty?
-          Value::Processor::Pipeline.new(processors: transformers)
-        end
+        return @value_transformer if defined?(@value_transformer)
+
+        @value_transformer = if transformers && !transformers.empty?
+                               Value::Processor::Pipeline.new(processors: transformers)
+                             end
       end
 
       # TODO: figure out how to safely memoize stuff so like this for performance reasons
       # A good way, but potentially a decent amount of work, is to have a class that takes value to its initialize
       # method.
       def value_validator
-        if validators && !validators.empty?
-          Value::Processor::Pipeline.new(processors: validators)
-        end
+        return @value_validator if defined?(@value_validator)
+
+        @value_validator = if validators && !validators.empty?
+                             Value::Processor::Pipeline.new(processors: validators)
+                           end
       end
 
       def element_processor
-        if element_processors && !element_processors.empty?
-          Value::Processor::Pipeline.new(processors: element_processors)
-        end
+        return @element_processor if defined?(@element_processor)
+
+        @element_processor = if element_processors && !element_processors.empty?
+                               Value::Processor::Pipeline.new(processors: element_processors)
+                             end
       end
 
       # TODO: some way of memoizing these values? Would need to introduce a new class that takes the value to its

data/projects/value/src/processor/casting.rb

@@ -37,57 +37,34 @@ module Foobara
           end
         end
 
-        attr_accessor :target_classes
+        attr_accessor :target_classes, :cast_even_if_instance_of_target_type
 
-        def initialize(*, casters:, target_classes: nil, **)
+        def initialize(*, casters:, target_classes: nil, cast_even_if_instance_of_target_type: nil, **)
           self.target_classes = Util.array(target_classes)
 
-          processors = [
-            *does_not_need_cast_processor,
-            *casters
-          ]
+          if cast_even_if_instance_of_target_type
+            self.cast_even_if_instance_of_target_type = true
+          end
+
+          super(*, processors: casters, **)
+        end
 
-          super(*, processors:, **)
+        def process_value(value)
+          if cast_even_if_instance_of_target_type || needs_cast?(value)
+            super
+          else
+            Outcome.success(value)
+          end
         end
 
         def needs_cast?(value)
-          !does_not_need_cast_processor.applicable?(value)
+          target_classes.none? { |klass| value.is_a?(klass) }
         end
 
         def can_cast?(value)
           processors.any? { |processor| processor.applicable?(value) }
         end
 
-        def does_not_need_cast_processor
-          return @does_not_need_cast_processor if defined?(@does_not_need_cast_processor)
-
-          errorified_name = target_classes.map do |c|
-            if c.name
-              c.name
-            elsif c.respond_to?(:foobara_name)
-              c.foobara_name
-            else
-              # TODO: test this code path
-              # :nocov:
-              "Anon"
-              # :nocov:
-            end
-          end.map { |name| name.split("::").last }.sort.join("Or")
-
-          class_name = "NoCastNeededIfIsA#{errorified_name}"
-
-          @does_not_need_cast_processor = if target_classes && !target_classes.empty?
-                                            Caster.subclass(
-                                              name: class_name,
-                                              applicable?: ->(value) {
-                                                target_classes.any? { |target_class| value.is_a?(target_class) }
-                                              },
-                                              applies_message: "be a #{target_classes.map(&:name).join(" or ")}",
-                                              cast: ->(value) { value }
-                                            ).instance
-                                          end
-        end
-
         def error_message(value)
           type = declaration_data[:cast_to]
 
@@ -101,7 +78,12 @@ module Foobara
         end
 
         def applies_message
-          Util.to_or_sentence(processors.map(&:applies_message).flatten)
+          Util.to_or_sentence(
+            [
+              "be a #{target_classes.map(&:name).join(" or ")}",
+              *processors.map(&:applies_message).flatten
+            ]
+          )
         end
 
         def error_context(value)

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.1.6".freeze
+    VERSION = "0.1.8".freeze
     MINIMUM_RUBY_VERSION = ">= 3.4.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Miles Georgi
@@ -304,6 +304,8 @@ files:
 - projects/entity/src/extensions/builtin_types/entity.rb
 - projects/entity/src/extensions/builtin_types/entity/casters/hash.rb
 - projects/entity/src/extensions/builtin_types/entity/casters/primary_key.rb
+- projects/entity/src/extensions/builtin_types/entity/casters/record_from_closed_transaction.rb
+- projects/entity/src/extensions/builtin_types/entity/casters/record_from_current_transaction.rb
 - projects/entity/src/extensions/builtin_types/entity/validators/model_instance_is_valid.rb
 - projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration.rb
 - projects/entity/src/extensions/type_declarations/handlers/extend_entity_type_declaration/attributes_handler_desugarizer.rb