foobara 0.0.142 → 0.1.2

data/projects/command_connectors/src/transformed_command.rb

@@ -333,34 +333,22 @@ module Foobara
       end
 
       def foobara_manifest
-        to_include = TypeDeclarations.foobara_manifest_context_to_include
+        to_include = TypeDeclarations.foobara_manifest_context_to_include || Set.new
 
         types = types_depended_on.select(&:registered?).map do |t|
-          if to_include
-            to_include << t
-          end
+          to_include << t
           t.foobara_manifest_reference
         end.sort
 
         inputs_transformers = TypeDeclarations.with_manifest_context(remove_sensitive: false) do
-          self.inputs_transformers.map(&:foobara_manifest)
-        end
-        result_transformers = self.result_transformers.map(&:foobara_manifest)
-        errors_transformers = self.errors_transformers.map(&:foobara_manifest)
-        pre_commit_transformers = self.pre_commit_transformers.map(&:foobara_manifest)
-        serializers = self.serializers.map do |s|
-          if s.respond_to?(:foobara_manifest)
-            if to_include
-              to_include << s
-            end
-            s.foobara_manifest_reference
-          else
-            { proc: s.to_s }
-          end
+          processors_to_manifest_symbols(self.inputs_transformers)
         end
-
-        response_mutators = mutators_to_manifest_symbols(self.response_mutators, to_include:)
-        request_mutators = mutators_to_manifest_symbols(self.request_mutators, to_include:)
+        result_transformers = processors_to_manifest_symbols(self.result_transformers)
+        errors_transformers = processors_to_manifest_symbols(self.errors_transformers)
+        pre_commit_transformers = processors_to_manifest_symbols(self.pre_commit_transformers)
+        serializers = processors_to_manifest_symbols(self.serializers)
+        response_mutators = processors_to_manifest_symbols(self.response_mutators)
+        request_mutators = processors_to_manifest_symbols(self.request_mutators)
 
         authenticator_details = if authenticator
                                   {
@@ -404,28 +392,32 @@ module Foobara
         )
       end
 
-      def mutators_to_manifest_symbols(mutators, to_include:)
-        return nil if mutators.nil? || mutators.empty?
+      def processors_to_manifest_symbols(processors)
+        return nil if processors.nil? || processors.empty?
+
+        to_include = TypeDeclarations.foobara_manifest_context_to_include || Set.new
+        include_processors = TypeDeclarations.include_processors?
 
-        mutators.map do |mutator|
-          if mutator.scoped_path_set?
-            to_include << mutator
-            mutator.foobara_manifest_reference
-          elsif mutator.is_a?(Value::Mutator)
-            klass = mutator.class
+        processors.map do |processor|
+          if processor.respond_to?(:scoped_path_set?) && processor.scoped_path_set?
+            if include_processors
+              to_include << processor
+            end
+            processor.foobara_manifest_reference
+          elsif processor.is_a?(Value::Processor)
+            klass = processor.class
 
             if klass.scoped_path_set?
-              to_include << klass
+              if include_processors
+                to_include << klass
+              end
               klass.foobara_manifest_reference
               # TODO: Delete this nocov block
               # TODO: make anonymous scoped path's have better names instead of random hexadecimal
               # :nocov:
-            elsif mutator.symbol
-              mutator.symbol
+            elsif processor.respond_to?(:symbol) && processor.symbol
+              processor.symbol
             else
-
-              to_include << klass if klass.scoped_path_set?
-
               name = klass.name
 
               while name.nil?
@@ -436,6 +428,12 @@ module Foobara
               "Anonymous#{Util.non_full_name(name)}"
               # :nocov:
             end
+          elsif processor.is_a?(::Proc)
+            "Proc"
+          else
+            # :nocov:
+            "Unknown"
+            # :nocov:
           end
         end
       end
@@ -502,7 +500,9 @@ module Foobara
       end
 
       def mutate_request(request)
-        request_mutator&.process_value!(request)
+        if request_mutator&.applicable?(request)
+          request_mutator.process_value!(request)
+        end
       end
 
       def result_transformer
@@ -594,8 +594,10 @@ module Foobara
     end
 
     def transform_inputs
-      self.transformed_inputs = if self.class.inputs_transformer
-                                  outcome = self.class.inputs_transformer.process_value(untransformed_inputs)
+      transformer = self.class.inputs_transformer
+
+      self.transformed_inputs = if transformer&.applicable?(untransformed_inputs)
+                                  outcome = transformer.process_value(untransformed_inputs)
 
                                   if outcome.success?
                                     outcome.result
@@ -625,17 +627,23 @@ module Foobara
     end
 
     def transform_result
-      if self.class.result_transformer
-        self.outcome = Outcome.success(self.class.result_transformer.process_value!(result))
+      transformer = self.class.result_transformer
+
+      if transformer&.applicable?(result)
+        self.outcome = Outcome.success(transformer.process_value!(result))
       end
     end
 
     def mutate_response(response)
-      self.class.response_mutator&.process_value!(response)
+      mutator = self.class.response_mutator
+
+      if mutator&.applicable?(response)
+        mutator.process_value!(response)
+      end
     end
 
     def transform_errors
-      if errors_transformer
+      if errors_transformer&.applicable?(errors)
         self.outcome = Outcome.errors(errors_transformer.process_value!(errors))
       end
     end
@@ -708,7 +716,9 @@ module Foobara
               source = if allowed_rule.block.respond_to?("source") && defined?(MethodSource)
                          begin
                            # This only works when pry is loaded
+                           # :nocov:
                            allowed_rule.block.source
+                           # :nocov:
                          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:
@@ -733,7 +743,9 @@ module Foobara
     def apply_pre_commit_transformers
       if pre_commit_transformer
         command.before_commit_transaction do |**|
-          pre_commit_transformer.process_value!(self)
+          if pre_commit_transformer.applicable?(self)
+            pre_commit_transformer.process_value!(self)
+          end
         end
       end
     end

data/projects/command_connectors/src/transformers/auth_errors_transformer.rb

@@ -20,6 +20,7 @@ module Foobara
             map
           end
         end
+
         def applicable?(_request)
           false
         end

data/projects/command_connectors/src/transformers/entity_to_primary_key_inputs_transformer.rb

@@ -48,6 +48,10 @@ module Foobara
             elsif to_type.extends?(Foobara::BuiltinTypes[:detached_entity])
               declaration = to_type.target_class.primary_key_type.reference_or_declaration_data
 
+              if declaration.is_a?(::Symbol)
+                declaration = { type: declaration  }
+              end
+
               description = "#{to_type.target_class.model_name} #{to_type.target_class.primary_key_attribute}"
 
               unless to_type.extends_directly?(Foobara::BuiltinTypes[:detached_entity]) ||

data/projects/common/src/possible_error.rb

@@ -48,39 +48,45 @@ module Foobara
     # TODO: technically does not belong in this project but maybe it should
     def foobara_manifest
       to_include = TypeDeclarations.foobara_manifest_context_to_include
+      include_processors = TypeDeclarations.include_processors?
 
       if to_include
         to_include << error_class
       end
 
-      if processor
-        processor_class = processor.class
-        if to_include
-          to_include << processor_class
-        end
+      h = key.to_h.merge(
+        key: key.to_s,
+        error: error_class.foobara_manifest_reference,
+        manually_added:
+      )
 
-        if processor.scoped_path_set?
-          # Unclear why nothing in the test suite passes through here.
-          # TODO: either test this or delete it.
-          # :nocov:
-          to_include << processor
-          processor_reference = processor.foobara_manifest_reference
-          # :nocov:
+      if include_processors
+        if processor
+          processor_class = processor.class
+          if to_include
+            to_include << processor_class
+          end
+
+          if processor.scoped_path_set?
+            # Unclear why nothing in the test suite passes through here.
+            # TODO: either test this or delete it.
+            # :nocov:
+            to_include << processor
+            processor_reference = processor.foobara_manifest_reference
+            # :nocov:
+          end
         end
-      end
 
-      processor_manifest_data = data unless processor_reference
+        processor_manifest_data = data unless processor_reference
 
-      Util.remove_blank(
-        key.to_h.merge(
-          key: key.to_s,
-          error: error_class.foobara_manifest_reference,
+        h.merge!(
           processor: processor_reference,
           processor_class: processor_class&.foobara_manifest_reference,
-          processor_manifest_data:,
-          manually_added:
+          processor_manifest_data:
         )
-      )
+      end
+
+      Util.remove_blank(h)
     end
   end
 end

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

@@ -20,7 +20,13 @@ module Foobara
           def type_declaration(...)
             raise "No primary key set yet" unless primary_key_attribute
 
-            super.merge(type: :detached_entity, primary_key: primary_key_attribute)
+            declaration = super
+
+            declaration[:type] = :detached_entity
+            declaration[:primary_key] = primary_key_attribute
+            declaration.is_absolutified = true
+
+            declaration
           end
 
           def set_model_type

data/projects/detached_entity/src/detached_entity_type.rb

@@ -25,11 +25,21 @@ module Foobara
         declaration_data = manifest[:declaration_data]
 
         if self.class.type_requires_conversion?(declaration_data[:type])
+          # TODO: No longer is hit in this test suite but ActiveRecordType needs this class
+          # and potentially this snippet of code in order to do the right thing.
+          # TODO: test that out and delete this method if possible.
+          # :nocov:
           declaration_data = declaration_data.merge(type: :detached_entity)
+          # :nocov:
         end
 
         if self.class.model_base_class_requires_conversion?(declaration_data[:model_base_class])
+          # TODO: No longer is hit in this test suite but ActiveRecordType needs this class
+          # and potentially this snippet of code in order to do the right thing.
+          # TODO: test that out and delete this method if possible.
+          # :nocov:
           declaration_data = declaration_data.merge(model_base_class: "Foobara::DetachedEntity")
+          # :nocov:
         end
 
         # TODO: remove private attributes, add delegated attributes

data/projects/detached_entity/src/extensions/builtin_types/detached_entity/validators/model_instance_is_valid.rb

@@ -5,7 +5,7 @@ module Foobara
         class ModelInstanceIsValid < Model::Validators::ModelInstanceIsValid
           # Why is this here in entity/ instead of in model/?
           def possible_errors
-            return [] if parent_declaration_data == { type: expected_type_symbol }
+            return [] if parent_declaration_data == expected_type_symbol
 
             # TODO: we should also ask the class if it is mutable...
             mutable = parent_declaration_data.key?(:mutable) ? parent_declaration_data[:mutable] : false

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/hash_desugarizer.rb

@@ -4,10 +4,8 @@ module Foobara
       class ExtendDetachedEntityTypeDeclaration < ExtendModelTypeDeclaration
         class HashDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            return false unless sugary_type_declaration.is_a?(::Hash)
-            return false unless Util.all_symbolizable_keys?(sugary_type_declaration)
-
-            sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
 
             type_symbol = sugary_type_declaration[:type] || sugary_type_declaration["type"]
             return false unless type_symbol
@@ -16,10 +14,9 @@ module Foobara
 
             return true if type_symbol == expected_type_symbol
 
-            if type_symbol.is_a?(::Symbol) && type_registered?(type_symbol)
-              type = Foobara.foobara_root_namespace.foobara_lookup_type(
-                type_symbol, mode: Namespace::LookupMode::ABSOLUTE
-              )
+            if type_symbol.is_a?(::Symbol)
+              type = sugary_type_declaration.type ||
+                     lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
 
               type&.extends?(BuiltinTypes[expected_type_symbol])
             end
@@ -30,7 +27,7 @@ module Foobara
           end
 
           def desugarize(sugary_type_declaration)
-            Util.symbolize_keys(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
           end
 
           def priority

data/projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/primary_key_desugarizer.rb

@@ -10,7 +10,8 @@ module Foobara
           end
 
           def desugarize(sugary_type_declaration)
-            sugary_type_declaration.merge(primary_key: sugary_type_declaration[:primary_key].to_sym)
+            sugary_type_declaration[:primary_key] = sugary_type_declaration[:primary_key].to_sym
+            sugary_type_declaration
           end
         end
       end

data/projects/domain/src/domain_module_extension.rb

@@ -316,7 +316,10 @@ module Foobara
           # TODO: introduce a Namespace#scope method to simplify this a bit
           Foobara::Namespace.use self do
             if block
-              args = [TypeDeclarations::Dsl::Attributes.to_declaration(&block), *args]
+              args = [
+                TypeDeclarations::Dsl::Attributes.to_declaration(&block).declaration_data,
+                *args
+              ]
             end
 
             attributes_type_declaration, *args = args
@@ -358,7 +361,7 @@ module Foobara
                              scoped_full_name
                            end
 
-            entity_type = foobara_type_builder.type_for_declaration(
+            declaration = TypeDeclaration.new(
               Util.remove_blank(
                 type: :entity,
                 name:,
@@ -366,11 +369,15 @@ module Foobara
                 model_module:,
                 attributes_declaration: attributes_type_declaration,
                 primary_key:,
-                description:,
-                _desugarized: { type_absolutified: true }
+                description:
               )
             )
 
+            declaration.is_absolutified = true
+            declaration.is_duped = true
+
+            entity_type = foobara_type_builder.type_for_declaration(declaration)
+
             entity_type.target_class
           end
         end
@@ -428,6 +435,7 @@ module Foobara
             foobara_depends_on_namespaces << domain
             foobara_type_builder.accesses << domain.foobara_type_builder
 
+            lru_cache.reset!
             foobara_depends_on << domain_name
           end
         end

data/projects/domain/src/is_manifestable.rb

@@ -38,7 +38,8 @@ module Foobara
     end
 
     def foobara_manifest
-      to_include = TypeDeclarations.foobara_manifest_context_to_include
+      to_include = TypeDeclarations.foobara_manifest_context_to_include || Set.new
+      include_processors = TypeDeclarations.include_processors?
 
       h = {
         scoped_path:,
@@ -53,17 +54,28 @@ module Foobara
         organization: foobara_organization&.foobara_manifest_reference
       }
 
-      parent = scoped_namespace
+      candidate = scoped_namespace
+      parent = nil
 
-      if parent
-        parent_category = Namespace.global.foobara_category_symbol_for(parent)
+      while candidate
+        parent_category = Namespace.global.foobara_category_symbol_for(candidate)
+        break unless parent_category
 
         if parent_category
-          if to_include
-            to_include << parent
+          if include_processors || (parent_category != :processor && parent_category != :processor_class)
+            if candidate != Foobara::Value
+              parent = candidate
+              break
+            end
           end
-          h[:parent] = [parent_category, parent.foobara_manifest_reference]
         end
+
+        candidate = candidate.scoped_namespace
+      end
+
+      if parent
+        to_include << parent
+        h[:parent] = [parent_category, parent.foobara_manifest_reference]
       end
 
       h

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

@@ -6,7 +6,12 @@ module Foobara
 
         module ClassMethods
           def type_declaration(...)
-            super.merge(type: :entity)
+            declaration = super
+
+            declaration[:type] = :entity
+            declaration.is_absolutified = true
+
+            declaration
           end
         end
       end

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

@@ -34,13 +34,13 @@ module Foobara
            "model",
            "detached_entity",
            "entity",
-           "model_attribute_helpers",
+           "persistence",
            "nested_transactionable",
-           "command",
-           "domain_mapper",
-           "persistence", # Feels like this would be loaded before command?
+           "model_attribute_helpers",
            "in_memory_crud_driver_minimal",
            "in_memory_crud_driver",
+           "command",
+           "domain_mapper",
            "manifest"
 
   install!

data/projects/manifest/src/foobara/manifest/type.rb

@@ -70,13 +70,22 @@ module Foobara
         scoped_full_name
       end
 
+      # TODO: replace this with primitive?
       def builtin?
         BuiltinTypes.builtin_reference?(reference)
       end
 
-      # Not sure the best way to define this...
+      def primitive?
+        declaration_data.is_a?(::String) || declaration_data.is_a?(::Symbol)
+      end
+
+      # This name is confusing.
+      # This represents a type that is 1) registered 2) not primitive 3) does not inherit from :model
+      # Because this is a Manifest::Type it is registered by definition. Non-registered types are
+      # represented in the manifest only as type declarations scattered the other categories where
+      # needed.
       def custom?
-        !builtin? && !model?
+        !primitive? && !extends_symbol?(:model)
       end
 
       def extends_symbol?(symbol)

data/projects/manifest/src/foobara/manifest/type_declaration.rb

@@ -90,6 +90,12 @@ module Foobara
         @custom = to_type.custom?
       end
 
+      def primitive?
+        if reference?
+          to_type.primitive?
+        end
+      end
+
       def to_model
         raise "not an model" unless model?
 
@@ -108,7 +114,12 @@ module Foobara
 
       def to_detached_entity
         raise "not an detached_entity" unless detached_entity?
-        raise "detached_entity extension instead of an detached_entity" unless relevant_manifest.size == 1
+
+        if to_type.primitive?
+          # :nocov:
+          raise "detached_entity extension instead of an detached_entity"
+          # :nocov:
+        end
 
         type = to_type
 
@@ -125,7 +136,12 @@ module Foobara
 
       def to_entity
         raise "not an entity" unless entity?
-        raise "entity extension instead of an entity" unless relevant_manifest.size == 1
+
+        if to_type.primitive?
+          # :nocov:
+          raise "entity extension instead of an entity"
+          # :nocov:
+        end
 
         type = to_type
 
@@ -138,6 +154,34 @@ module Foobara
         # awkward??
         @to_type ||= find_type(self)
       end
+
+      def type
+        if reference?
+          relevant_manifest
+        else
+          super
+        end
+      end
+
+      def sensitive
+        if reference?
+          false
+        else
+          super
+        end
+      end
+
+      def sensitive_exposed
+        if reference?
+          false
+        else
+          super
+        end
+      end
+
+      def reference?
+        relevant_manifest.is_a?(::Symbol) || relevant_manifest.is_a?(::String)
+      end
     end
   end
 end

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

@@ -8,6 +8,14 @@ module Foobara
           def model_name(...)
             foobara_model_name(...)
           end
+
+          def delegates(...)
+            foobara_delegates(...)
+          end
+
+          def private_attribute_names
+            foobara_private_attribute_names
+          end
         end
       end
     end

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

@@ -23,8 +23,8 @@ module Foobara
               model_name: foobara_model_name,
               model_base_class: foobara_type.declaration_data[:model_base_class],
               model_class: foobara_type.declaration_data[:model_class],
-              delegates:,
-              private: private_attribute_names
+              delegates: foobara_delegates,
+              private: foobara_private_attribute_names
             )
           end
         end