foobara 0.0.142 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6defed2fda94d3c5f244f9f24eb9a32f4d06999bc773071dc58667565518499
-  data.tar.gz: 98a0f663a38ce6b105f78fbbefdc1e34328654ec54755daa379df824753f3214
+  metadata.gz: 772c1b159a33ecf7e3f63a1a2a70d8574d986be541bf3ac88cd00a87c8fc8036
+  data.tar.gz: 94ccbde2bafcb9860d7275083659cd8f62f76f8d7bc27b03fcfa2d63e3e085ff
 SHA512:
-  metadata.gz: 9c42abcbd62eba3583acfd4345df530ec04efdc18d19773ce1ed5dafa9e0d43d09364b2b45355a22874b2aeaf030d476726cbd214ec1a3626812b2a20c35133f
-  data.tar.gz: 7cc3b4e13250e4cc2b3af8468b2f5774861161fcc13972ecc87f17c1682bd8a69170a080b6f9cc72249ff5756d2a7f1ca509dfaeba2ac52bbf9896c8b9a4f3e6
+  metadata.gz: a78ea31d30819836a421d49413f2ce379262dac03bf2cc4db2d779c74cc98ea4580f48bd7b472e5d473e3edf269f31af17927adc0248f1ecd7436127585b4e21
+  data.tar.gz: cf07fcd19587a5820afb06f4cba5d783f2f340f552f64fdb8a577bd5794f139e513828ddb97a8263f41c1d31c104b1d34bb1dfec751da3aa0da43d75c78d660d

data/.ruby-version

@@ -1 +1 @@
-3.4.3
+3.4.5

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+# [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` 
+  instead of a `{ type: :some_type }` structure. This makes things faster and also make things less ambiguous.
+- Order entity bases and transaction tables by dependencies to simplify making sure associations
+  already have their primary keys set
+- Add Manifest::Type#primitive? and Manifest::TypeDeclaration#primitive?/#reference?
+- Add Type#primitive? and Type#derived? concepts
+- Add ABSOLUTE_SINGLE_NAMESPACE and refactor #foobara_lookup to be much faster
+- Checking #applicable? is now the caller's responsibility when running value processors
+- Run RSpec and Rubocop in separate jobs in CI
+- Don't load pry by default
+- Introduce TypeDeclaration and use it to eliminate some desugarizers and speed things up significantly
+  while also improving code readability
+- Eliminate `_desugarized` metadata entry from declaration data now that TypeDeclaration can encapsulate
+  such state
+- Lazy load Type#element_type(s) and strictify them
+- Fix bug where .add_inputs is called when .inputs was never called
+
 # [0.0.142] - 2025-08-10
 
 - Add LruCache to IsNamespace to speed up lookups

data/projects/builtin_types/lib/foobara/builtin_types.rb

@@ -3,6 +3,7 @@ require "time"
 require "bigdecimal"
 
 module Foobara
+  # TODO: rename this to PrimitiveTypes and deprecate the name BuiltinTypes
   module BuiltinTypes
     class << self
       def builtin_types

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_defaults_from_element_types_to_root.rb

@@ -8,12 +8,19 @@ module Foobara
               module Desugarizers
                 class MoveDefaultsFromElementTypesToRoot < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes && value.key?(:element_type_declarations)
+                    value.hash? && value[:type] == :attributes && value.key?(:element_type_declarations)
                   end
 
                   def desugarize(rawish_type_declaration)
                     defaults = rawish_type_declaration[:defaults]
-                    defaults = defaults ? defaults.dup : {}
+
+                    if defaults
+                      unless rawish_type_declaration.deep_duped?
+                        defaults = defaults.dup
+                      end
+                    else
+                      defaults = {}
+                    end
 
                     element_type_declarations = rawish_type_declaration[:element_type_declarations]
 

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/symbolize_defaults.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class SymbolizeDefaults < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes && value[:defaults]
+                    value.hash? && value[:type] == :attributes && value[:defaults]
                   end
 
                   def desugarize(rawish_type_declaration)

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/hash_with_symbolic_keys.rb

@@ -16,7 +16,7 @@ module Foobara
                   end
 
                   def applicable?(strict_type_declaration)
-                    strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:defaults)
+                    strict_type_declaration.hash? && strict_type_declaration.key?(:defaults)
                   end
 
                   def validation_errors(strict_type_declaration)

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/alphabetize_required.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class AlphabetizeRequired < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes &&
+                    value.hash? && value[:type] == :attributes &&
                       value.key?(:required) && value[:required].size > 1
                   end
 
@@ -17,11 +17,11 @@ module Foobara
 
                     sorted_required = required.sort
 
-                    if sorted_required == required
-                      rawish_type_declaration
-                    else
-                      rawish_type_declaration.merge(required: sorted_required)
+                    if sorted_required != required
+                      rawish_type_declaration[:required] = sorted_required
                     end
+
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_required_from_element_types_to_root.rb

@@ -8,7 +8,9 @@ module Foobara
               module Desugarizers
                 class MoveRequiredFromElementTypesToRoot < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    value.is_a?(::Hash) && value[:type] == :attributes && value.key?(:element_type_declarations)
+                    return false if value.strict?
+
+                    value.hash? && value[:type] == :attributes && value.key?(:element_type_declarations)
                   end
 
                   def desugarize(rawish_type_declaration)
@@ -24,13 +26,17 @@ module Foobara
 
                     element_type_declarations = rawish_type_declaration[:element_type_declarations]
 
+                    changed = false
+
                     element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
                       if attribute_type_declaration.is_a?(::Hash) && attribute_type_declaration.key?(:required)
                         is_required = attribute_type_declaration[:required]
 
-                        if [true, false].include?(is_required)
+                        if is_required == true || is_required == false
                           element_type_declarations[attribute_name] = attribute_type_declaration.except(:required)
 
+                          changed = true
+
                           if is_required
                             required_attributes << attribute_name
                           else
@@ -46,6 +52,10 @@ module Foobara
                       rawish_type_declaration[:required] = required_attributes
                     end
 
+                    if changed
+                      rawish_type_declaration[:element_type_declarations] = element_type_declarations
+                    end
+
                     rawish_type_declaration
                   end
                 end

data/projects/builtin_types/src/builtin_types.rb

@@ -16,7 +16,7 @@ module Foobara
         description: "Built-in #{type_symbol} type",
         type_module: nil
       )
-        declaration_data = { type: type_symbol.to_sym }
+        declaration_data = type_symbol.to_sym
 
         module_symbol = Util.classify(type_symbol).to_sym
 

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/class_desugarizer.rb

@@ -8,11 +8,19 @@ module Foobara
               module Desugarizers
                 class ClassDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Class)
+                    rawish_type_declaration.class?
                   end
 
                   def desugarize(rawish_type_declaration)
-                    { type: :duck, instance_of: rawish_type_declaration.name }
+                    rawish_type_declaration.declaration_data = {
+                      type: :duck,
+                      instance_of: rawish_type_declaration.declaration_data.name
+                    }
+                    rawish_type_declaration.is_strict = true
+                    rawish_type_declaration.is_deep_duped = true
+                    rawish_type_declaration.is_duped = true
+
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/class_type_desugarizer.rb

@@ -8,14 +8,19 @@ module Foobara
               module Desugarizers
                 class ClassTypeDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    return false unless rawish_type_declaration.is_a?(::Hash)
+                    return false unless rawish_type_declaration.hash?
 
                     rawish_type_declaration[:type].is_a?(::Class)
                   end
 
                   def desugarize(rawish_type_declaration)
                     klass = rawish_type_declaration[:type]
-                    rawish_type_declaration.merge(type: :duck, instance_of: klass.name)
+
+                    rawish_type_declaration[:type] = :duck
+                    rawish_type_declaration[:instance_of] = klass.name
+                    rawish_type_declaration.is_absolutified = true
+
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/instance_of_class_desugarizer.rb

@@ -8,13 +8,12 @@ module Foobara
               module Desugarizers
                 class InstanceOfClassDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:instance_of].is_a?(::Class)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:instance_of].is_a?(::Class)
                   end
 
                   def desugarize(rawish_type_declaration)
-                    instance_of = rawish_type_declaration[:instance_of]
-                    instance_of = instance_of.name
-                    rawish_type_declaration.merge(instance_of:)
+                    rawish_type_declaration[:instance_of] = rawish_type_declaration[:instance_of].name
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/instance_of_symbol_desugarizer.rb

@@ -8,13 +8,12 @@ module Foobara
               module Desugarizers
                 class InstanceOfSymbolDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:instance_of].is_a?(::Symbol)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:instance_of].is_a?(::Symbol)
                   end
 
                   def desugarize(rawish_type_declaration)
-                    instance_of = rawish_type_declaration[:instance_of]
-                    instance_of = instance_of.to_s
-                    rawish_type_declaration.merge(instance_of:)
+                    rawish_type_declaration[:instance_of] = rawish_type_declaration[:instance_of].to_s
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/type_declaration_validators/is_valid_class.rb

@@ -16,7 +16,7 @@ module Foobara
                   end
 
                   def applicable?(strict_type_declaration)
-                    strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:instance_of)
+                    strict_type_declaration.hash? && strict_type_declaration.key?(:instance_of)
                   end
 
                   def validation_errors(strict_type_declaration)

data/projects/builtin_types/src/duck/supported_validators/instance_of.rb

@@ -30,6 +30,7 @@ module Foobara
 
           def validation_errors(value)
             klass = Object.const_get(expected_class_name)
+
             unless value.is_a?(klass)
               build_error(value)
             end

data/projects/builtin_types/src/duck/supported_validators/one_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/cast_one_of.rb

@@ -8,19 +8,20 @@ module Foobara
               module Desugarizers
                 class CastOneOf < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:one_of].is_a?(::Array)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:one_of].is_a?(::Array)
                   end
 
                   def desugarize(rawish_type_declaration)
                     one_of = rawish_type_declaration[:one_of]
 
+                    # TODO: for performance, can we just use the type identified by type: when possible?
                     type = type_for_declaration(rawish_type_declaration.except(:one_of))
 
-                    one_of = one_of.map do |value|
+                    rawish_type_declaration[:one_of] = one_of.map do |value|
                       type.process_value!(value)
                     end
 
-                    rawish_type_declaration.merge(one_of:)
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/duck/supported_validators/one_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/module_desugarizer.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class ModuleDesugarizer < TypeDeclarations::Desugarizer
                   def applicable?(rawish_type_declaration)
-                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:one_of].is_a?(::Module)
+                    rawish_type_declaration.hash? && rawish_type_declaration[:one_of].is_a?(::Module)
                   end
 
                   def desugarize(rawish_type_declaration)
@@ -16,7 +16,7 @@ module Foobara
 
                     one_of = Util.constant_values(mod)
 
-                    one_of = begin
+                    rawish_type_declaration[:one_of] = begin
                       one_of.sort
                     rescue
                       # :nocov:
@@ -24,7 +24,7 @@ module Foobara
                       # :nocov:
                     end
 
-                    rawish_type_declaration.merge(one_of:)
+                    rawish_type_declaration
                   end
 
                   def priority

data/projects/builtin_types/src/tuple/supported_processors/element_type_declarations/type_declaration_extension/extend_tuple_type_declaration/desugarizers/set_size.rb

@@ -8,7 +8,7 @@ module Foobara
               module Desugarizers
                 class SetSize < TypeDeclarations::Desugarizer
                   def applicable?(value)
-                    if value.is_a?(::Hash)
+                    if value.hash?
                       value.key?(:element_type_declarations) && value[:type] == :tuple && !value.key?(:size)
                     end
                   end

data/projects/builtin_types/src/tuple/supported_processors/element_type_declarations/type_declaration_extension/extend_tuple_type_declaration/type_declaration_validators/size_matches.rb

@@ -12,8 +12,7 @@ module Foobara
                       def context_type_declaration
                         {
                           expected_size: :integer,
-                          actual_size: :integer,
-                          value: :array
+                          actual_size: :integer
                         }
                       end
                     end
@@ -33,8 +32,7 @@ module Foobara
                         message: "Expected tuple to have #{size} elements but it had #{element_type_declarations_size}",
                         context: {
                           expected_size: size,
-                          actual_size: element_type_declarations_size,
-                          value: strict_type_declaration
+                          actual_size: element_type_declarations_size
                         }
                       )
                     end

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

@@ -26,13 +26,17 @@ module Foobara
           end
 
           def add_inputs(...)
-            new_type = type_for_declaration(...)
-            new_declaration = TypeDeclarations::Attributes.merge(
-              inputs_type.declaration_data,
-              new_type.declaration_data
-            )
-
-            inputs new_declaration
+            if inputs_type
+              new_type = type_for_declaration(...)
+              new_declaration = TypeDeclarations::Attributes.merge(
+                inputs_type.declaration_data,
+                new_type.declaration_data
+              )
+
+              inputs new_declaration
+            else
+              inputs(...)
+            end
           end
 
           def inputs_type
@@ -43,10 +47,6 @@ module Foobara
                            end
           end
 
-          def raw_inputs_type_declaration
-            inputs_type.raw_declaration_data
-          end
-
           def inputs_type_declaration
             inputs_type.declaration_data
           end
@@ -61,7 +61,7 @@ module Foobara
           end
         end
 
-        foobara_delegate :inputs_type, :raw_inputs_type_declaration, to: :class
+        foobara_delegate :inputs_type, to: :class
       end
     end
   end

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

@@ -24,8 +24,10 @@ module Foobara
             to_include = TypeDeclarations.foobara_manifest_context_to_include
 
             depends_on = self.depends_on.map do |command_name|
-              other_command = Foobara::Namespace.global.foobara_lookup!(command_name,
-                                                                        mode: Foobara::Namespace::LookupMode::ABSOLUTE)
+              other_command = Foobara::Namespace.global.foobara_lookup!(
+                command_name,
+                mode: Foobara::Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+              )
               if to_include
                 to_include << other_command
               end

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

@@ -16,10 +16,6 @@ module Foobara
                              superclass.result_type
                            end
           end
-
-          def raw_result_type_declaration
-            result_type.raw_declaration_data
-          end
         end
 
         foobara_delegate :result_type, :raw_result_type_declaration, to: :class

data/projects/command_connectors/src/command_connector.rb

@@ -494,8 +494,7 @@ module Foobara
       to_include << command_registry.global_organization
       to_include << command_registry.global_domain
 
-      # ABSOLUTE lets us get all of the children but not include dependent domains (GlobalDomain)
-      command_registry.foobara_each(mode: Namespace::LookupMode::ABSOLUTE) do |exposed_whatever|
+      command_registry.foobara_each(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) do |exposed_whatever|
         to_include << exposed_whatever
       end
 
@@ -507,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
@@ -537,25 +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)
-                    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
-                    ).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
-                    ).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
 
@@ -649,7 +674,7 @@ module Foobara
     def all_exposed_commands
       process_delayed_connections
 
-      command_registry.foobara_all_command(mode: Namespace::LookupMode::ABSOLUTE)
+      command_registry.foobara_all_command(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
     end
 
     def all_exposed_type_names

data/projects/command_connectors/src/command_registry.rb

@@ -34,7 +34,8 @@ module Foobara
 
     def create_exposed_command(command_class, **)
       full_domain_name = command_class.domain.scoped_full_name
-      exposed_domain = foobara_lookup_domain(full_domain_name, mode: Namespace::LookupMode::ABSOLUTE) ||
+      exposed_domain = foobara_lookup_domain(full_domain_name,
+                                             mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
                        build_and_register_exposed_domain(full_domain_name)
 
       exposed_command = create_exposed_command_without_domain(command_class, **)
@@ -81,7 +82,7 @@ module Foobara
 
       exposed_organization = foobara_lookup_organization(
         full_organization_name,
-        mode: Namespace::LookupMode::ABSOLUTE
+        mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
       ) || build_and_register_exposed_organization(full_organization_name)
 
       exposed_domain = Module.new
@@ -108,13 +109,15 @@ module Foobara
     end
 
     def global_domain
-      foobara_lookup_domain("") || build_and_register_exposed_domain("")
+      foobara_lookup_domain("", mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
+        build_and_register_exposed_domain("")
     end
 
     def global_organization
       # TODO: test this
       # :nocov:
-      foobara_lookup_organization("") || build_and_register_exposed_organization("")
+      foobara_lookup_organization("", mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
+        build_and_register_exposed_organization("")
       # :nocov:
     end