foobara 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdaf6b7b731daba3eefc95587311b462b0dcd05372e879410396ce7c3de1624f
-  data.tar.gz: a60835ec80262ed79f24d3dad4189d3f3eacd5516e1e0d137ba1e7dd30d6422e
+  metadata.gz: 772c1b159a33ecf7e3f63a1a2a70d8574d986be541bf3ac88cd00a87c8fc8036
+  data.tar.gz: 94ccbde2bafcb9860d7275083659cd8f62f76f8d7bc27b03fcfa2d63e3e085ff
 SHA512:
-  metadata.gz: e12bd29804a5ca80e08796d719e023d6aa5daeeae9e5f14296ff61cc3c1833d5ed660da186e8816e3f0c2fa929af5c9b0ff1ddcb4d4f093df8b7fa9ecbd8961e
-  data.tar.gz: 568db83480a82cb3420f9a4286be408a020a02308947759cd6b1115a4e98f2d7af21a9cc2bef41414c1327b15e0de6e4ac836ce879ca2150fa6da054e68f1120
+  metadata.gz: a78ea31d30819836a421d49413f2ce379262dac03bf2cc4db2d779c74cc98ea4580f48bd7b472e5d473e3edf269f31af17927adc0248f1ecd7436127585b4e21
+  data.tar.gz: cf07fcd19587a5820afb06f4cba5d783f2f340f552f64fdb8a577bd5794f139e513828ddb97a8263f41c1d31c104b1d34bb1dfec751da3aa0da43d75c78d660d

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# [0.1.2] - 2025-08-24
+
+- Exclude processor/processor_class categories from manifest by default
+- Fix bug where entity types were not converted to detached_entity types in manifests
+- Shorten cast_to declarations by using references when possible
+
 # [0.1.1] - 2025-08-22
 
 - Change type declarations for references to registered types to have a structure of `:some_type` 

data/projects/command_connectors/src/command_connector.rb

@@ -506,11 +506,16 @@ module Foobara
         domain: {},
         type: {},
         command: {},
-        error: {},
-        processor: {},
-        processor_class: {}
+        error: {}
       }
 
+      if TypeDeclarations.include_processors?
+        h.merge!(
+          processor: {},
+          processor_class: {}
+        )
+      end
+
       TypeDeclarations.with_manifest_context(to_include: additional_to_include, remove_sensitive: true) do
         until to_include.empty? && additional_to_include.empty?
           object = nil
@@ -536,26 +541,47 @@ module Foobara
                         "Make sure these are not included."
                 # :nocov:
                 else
+                  mode = Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
                   domain_name = o.foobara_domain.scoped_full_name
 
-                  unless command_registry.foobara_registered?(domain_name,
-                                                              mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
-                    command_registry.build_and_register_exposed_domain(domain_name)
+                  exposed_domain = command_registry.foobara_lookup_domain(domain_name, mode:)
+
+                  unless exposed_domain
+                    exposed_domain = command_registry.build_and_register_exposed_domain(domain_name)
 
                     # Since we don't know which other domains/orgs creating this domain might have created,
                     # we will just add them all to be included just in case
-                    command_registry.foobara_all_domain(
-                      mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
-                    ).each do |exposed_domain|
+                    command_registry.foobara_all_domain(mode:).each do |exposed_domain|
                       additional_to_include << exposed_domain
                     end
 
-                    command_registry.foobara_all_organization(
-                      mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
-                    ).each do |exposed_organization|
+                    command_registry.foobara_all_organization(mode:).each do |exposed_organization|
                       additional_to_include << exposed_organization
                     end
                   end
+
+                  if o.extends_type?(BuiltinTypes[:entity])
+                    declaration_data = o.declaration_data
+
+                    if declaration_data.is_a?(::Hash) && declaration_data[:type] == :entity
+                      if o.foobara_root_namespace != command_registry.foobara_root_namespace
+                        # Let's swap it out with a detached type
+                        detached_entity = command_registry.foobara_lookup_type(o.scoped_full_name, mode:)
+
+                        unless detached_entity
+                          declaration_data = o.declaration_data.merge(
+                            type: :detached_entity,
+                            model_base_class: "Foobara::DetachedEntity"
+                          )
+
+                          detached_entity = exposed_domain.foobara_type_from_declaration(declaration_data)
+                        end
+
+                        additional_to_include << detached_entity
+                        next
+                      end
+                    end
+                  end
                 end
               end
 
@@ -586,9 +612,8 @@ module Foobara
                         Foobara::Namespace.current
                       end
 
-          cat = h[category_symbol] ||= {}
           # TODO: do we really need to enter the namespace here for this?
-          cat[manifest_reference] = Foobara::Namespace.use namespace do
+          h[category_symbol][manifest_reference] = Foobara::Namespace.use namespace do
             object.foobara_manifest
           end
 

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)
+          processors_to_manifest_symbols(self.inputs_transformers)
         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
-        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

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/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/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/type_declarations/src/type_declarations.rb

@@ -99,6 +99,10 @@ module Foobara
         foobara_manifest_context_mode == Mode::STRINGIFIED || strict_stringified?
       end
 
+      def include_processors?
+        foobara_manifest_context_include_processors?
+      end
+
       # TODO: we should desugarize these but can't because of a bug where desugarizing entities results in creating the
       # entity class in memory, whoops.
       def declarations_equal?(declaration1, declaration2)
@@ -112,8 +116,8 @@ module Foobara
         Thread.inheritable_thread_local_var_get("foobara_manifest_context")
       end
 
-      allowed_context_keys = [:detached, :to_include, :mode, :remove_sensitive]
-      booleans = [:detached, :remove_sensitive]
+      allowed_context_keys = [:detached, :to_include, :mode, :remove_sensitive, :include_processors]
+      booleans = [:detached, :remove_sensitive, :include_processors]
 
       booleans.each do |context_item|
         define_method "foobara_manifest_context_#{context_item}?" do
@@ -144,84 +148,3 @@ module Foobara
     end
   end
 end
-
-=begin
-how many handlers do we need??
-
-
-find registered type by symbol
-
-extend registered type (find it by symbol and use it to construct new type with additional processors)
-
-Duck
-  AtomicDuck
-    Number
-      Integer
-        BigInteger
-      Float
-        BigDecimal
-    String
-      Email
-      Phone
-    Datetime
-    Date
-    Boolean
-  Duckture
-    Array
-      Tuple
-      AssociativeArray
-        Attributes
-          Model
-            Address
-              UsAddress
-            Entity
-
-Duck (RegisteredTypeExtensionTypeDeclarationHandler)
-  AtomicDuck (N/A)
-    Number (N/A)
-      Integer (RegisteredTypeExtensionTypeDeclarationHandler)
-        BigInteger (RegisteredTypeExtensionTypeDeclarationHandler)
-      Float (RegisteredTypeExtensionTypeDeclarationHandler)
-        BigDecimal (RegisteredTypeExtensionTypeDeclarationHandler)
-    String (RegisteredTypeExtensionTypeDeclarationHandler)
-      Email (implement in terms of string extension)
-      Phone (implement in terms of string extension)
-    Datetime (RegisteredTypeExtensionTypeDeclarationHandler)
-    Date (RegisteredTypeExtensionTypeDeclarationHandler)
-    Boolean (RegisteredTypeExtensionTypeDeclarationHandler)
-  Duckture (N/A)
-    Array (hmmmm we need an element processor initialized with the element type...)
-      Tuple (hmmmm we need an element processor initialized with the elements type...)
-      AssociativeArray (hmmmm we need an element processor initialized with the key type and the value type...)
-        Attributes (we need an element processor initialized with the attribute_types)
-          Model (same as above but need to add a name attribute...)
-            Address (implement in terms of model)
-              UsAddress (implement in terms of Address)
-            Entity (same as above but with a primary key processor of some sort)
-
-
-TypeDeclarationHandler
-  RegisteredAtomTypeExtensionTypeDeclarationHandler
-  RegisteredStructuredTypeExtensionTypeDeclarationHandler
-    ExtendArrayTypeDeclarationHandler
-    ExtendTupleTypeDeclarationHandler
-    ExtendAssociativeArrayTypeDeclaration
-    ExtendAttributesTypeDeclaration
-    ExtendModelTypeDeclarationHandler
-    ExtendEntityTypeDeclarationHandler
-
-I think we need these type declarations but not necessarily Type subclasses for all of these types
-
-Maybe just one Type class??
-
-let's see...
-
-for atom could just not support element_types nor size
-for array element_types could just be applied repeating?? Kind of goofy
-For tuple element_types could be applied repeating and size validator could be added
-for associative array... element_types need to be a hash instead of an array. Is that OK?
-  Or could be an array of pairs... like Hash#to_a ? Maybe we just operate off of #each? Seems that will work, wow...
-For Attributes same as associative array but with key processor of symbol plus an attributes_processor
-For model add a name processor
-for entity add a primary key processor of some sort...
-=end

data/projects/types/src/type.rb

@@ -330,7 +330,7 @@ module Foobara
                          end
 
         Value::Processor::Casting.new(
-          { cast_to: declaration_data },
+          { cast_to: reference_or_declaration_data },
           casters:,
           target_classes:,
           enforce_unique:
@@ -416,6 +416,7 @@ module Foobara
       def foobara_manifest
         to_include = TypeDeclarations.foobara_manifest_context_to_include
         remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+        include_processors = TypeDeclarations.include_processors?
 
         types = []
 
@@ -455,11 +456,13 @@ module Foobara
           h[:sensitive_exposed] = true
         end
 
-        h.merge!(
-          supported_processor_manifest.merge(
-            Util.remove_blank(processors: processor_manifest)
+        if include_processors
+          h.merge!(
+            supported_processor_manifest.merge(
+              Util.remove_blank(processors: processor_manifest)
+            )
           )
-        )
+        end
 
         target_classes.sort_by(&:name).each do |target_class|
           if target_class.respond_to?(:foobara_manifest)

data/projects/value/src/processor.rb

@@ -322,12 +322,6 @@ module Foobara
       def foobara_manifest
         to_include = TypeDeclarations.foobara_manifest_context_to_include
 
-        unless scoped_path_set?
-          if self.class.scoped_path_set?
-            self.scoped_path = self.class.scoped_path
-          end
-        end
-
         possible_errors = self.possible_errors.map do |possible_error|
           [possible_error.key.to_s, possible_error.foobara_manifest]
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Miles Georgi
@@ -538,7 +538,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.1
 specification_version: 4
 summary: A command-centric and discoverable software framework with a focus on domain
   concepts and abstracting away integration code