foobara 0.2.6 → 0.3.0

data/projects/command_connectors/src/transformed_command.rb

@@ -425,52 +425,6 @@ module Foobara
         manifest
       end
 
-      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?
-
-        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?
-              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 processor.respond_to?(:symbol) && processor.symbol
-              processor.symbol
-            else
-              name = klass.name
-
-              while name.nil?
-                klass = klass.superclass
-                name = klass.name
-              end
-
-              "Anonymous#{Util.non_full_name(name)}"
-              # :nocov:
-            end
-          elsif processor.is_a?(::Proc)
-            "Proc"
-          else
-            # :nocov:
-            "Unknown"
-            # :nocov:
-          end
-        end
-      end
-
       def inputs_transformer
         return @inputs_transformer if defined?(@inputs_transformer)
 
@@ -581,6 +535,54 @@ module Foobara
           end
         end
       end
+
+      private
+
+      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?
+
+        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?
+              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 processor.respond_to?(:symbol) && processor.symbol
+              processor.symbol
+            else
+              name = klass.name
+
+              while name.nil?
+                klass = klass.superclass
+                name = klass.name
+              end
+
+              "Anonymous#{Util.non_full_name(name)}"
+              # :nocov:
+            end
+          elsif processor.is_a?(::Proc)
+            "Proc"
+          else
+            # :nocov:
+            "Unknown"
+            # :nocov:
+          end
+        end
+      end
     end
 
     attr_accessor :command, :untransformed_inputs, :transformed_inputs, :outcome, :request
@@ -626,23 +628,6 @@ module Foobara
       request.authenticated_credential
     end
 
-    def transform_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
-                                  else
-                                    self.outcome = outcome
-                                    untransformed_inputs
-                                  end
-                                else
-                                  untransformed_inputs
-                                end
-    end
-
     def inputs
       return @inputs if defined?(@inputs)
 
@@ -727,6 +712,60 @@ module Foobara
       end
     end
 
+    def result
+      outcome.result
+    end
+
+    def errors
+      outcome.errors
+    end
+
+    # TODO: kill this
+    def serialize_result(body)
+      if serializer
+        serializer.process_value!(body)
+      else
+        body
+      end
+    end
+
+    def raw_inputs
+      untransformed_inputs
+    end
+
+    def method_missing(method_name, ...)
+      if command.respond_to?(method_name)
+        command.send(method_name, ...)
+      else
+        # :nocov:
+        super
+        # :nocov:
+      end
+    end
+
+    def respond_to_missing?(method_name, private = false)
+      command.respond_to?(method_name, private) || super
+    end
+
+    private
+
+    def transform_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
+                                  else
+                                    self.outcome = outcome
+                                    untransformed_inputs
+                                  end
+                                else
+                                  untransformed_inputs
+                                end
+    end
+
     def construct_command
       self.command = command_class.new(transformed_inputs)
     end
@@ -804,18 +843,6 @@ module Foobara
       end
     end
 
-    def result
-      outcome.result
-    end
-
-    def errors
-      outcome.errors
-    end
-
-    def flush_transactions
-      request.opened_transactions&.reverse&.each(&:flush!)
-    end
-
     def transform_outcome
       if outcome.success?
         # can we do this while still in the transaction of the command???
@@ -825,31 +852,8 @@ module Foobara
       end
     end
 
-    # TODO: kill this
-    def serialize_result(body)
-      if serializer
-        serializer.process_value!(body)
-      else
-        body
-      end
-    end
-
-    def raw_inputs
-      untransformed_inputs
-    end
-
-    def method_missing(method_name, ...)
-      if command.respond_to?(method_name)
-        command.send(method_name, ...)
-      else
-        # :nocov:
-        super
-        # :nocov:
-      end
-    end
-
-    def respond_to_missing?(method_name, private = false)
-      command.respond_to?(method_name, private) || super
+    def flush_transactions
+      request.opened_transactions&.reverse&.each(&:flush!)
     end
   end
 end

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

@@ -6,6 +6,8 @@ module Foobara
           load_atoms(object)
         end
 
+        private
+
         def load_atoms(object)
           case object
           when Entity

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

@@ -14,6 +14,8 @@ module Foobara
           request
         end
 
+        private
+
         def load_delegated_attribute_entities(object)
           case object
           when Entity

data/projects/detached_entity/lib/foobara/detached_entity.rb

@@ -13,6 +13,8 @@ module Foobara
 
         model = Namespace.global.foobara_lookup_type!(:model)
         BuiltinTypes.build_and_register!(:detached_entity, model, nil)
+
+        TypeDeclarations::RemoveSensitiveValuesTransformer.include(RemoveSensitiveValuesTransformerExtensions)
       end
 
       def reset_all

data/projects/detached_entity/src/remove_sensitive_values_transformer_extensions.rb

@@ -0,0 +1,64 @@
+module Foobara
+  class DetachedEntity < Model
+    module RemoveSensitiveValuesTransformerExtensions
+      def from(...)
+        super.tap do
+          create_all_association_types_in_current_namespace(from_type)
+        end
+      end
+
+      def to(...)
+        super.tap do
+          create_all_association_types_in_current_namespace(to_type)
+        end
+      end
+
+      def create_all_association_types_in_current_namespace(type)
+        already_sanitized = Set.new
+
+        associations = Foobara::DetachedEntity.construct_deep_associations(type)
+
+        associations&.values&.reverse&.each do |entity_type|
+          next if already_sanitized.include?(entity_type)
+
+          next if entity_type.sensitive?
+
+          unless entity_type.has_sensitive_types?
+            already_sanitized << entity_type
+            next
+          end
+
+          ns = Namespace.current
+
+          declaration = entity_type.declaration_data
+          sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
+
+          existing_type = ns.foobara_lookup(
+            entity_type.full_type_symbol,
+            mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+          )
+
+          if existing_type
+            if existing_type.declaration_data == sanitized_type_declaration
+              already_sanitized << entity_type
+              already_sanitized << existing_type
+              next
+            else
+              # :nocov:
+              raise "Did not expect to be re-sanitizing #{entity_type.full_type_symbol}"
+              # :nocov:
+            end
+
+          end
+
+          # We want to make sure that any types that change due to having sensitive types
+          # has a corresponding registered type in the command registry domain if needed
+          # TODO: this all feels so messy and brittle.
+          Domain.current.foobara_type_from_declaration(sanitized_type_declaration)
+
+          already_sanitized << entity_type
+        end
+      end
+    end
+  end
+end

data/projects/domain/src/domain_module_extension.rb

@@ -310,27 +310,6 @@ module Foobara
           type
         end
 
-        def foobara_register_model(model_class)
-          type = model_class.model_type
-
-          full_name = type.scoped_full_name
-
-          if model_class.full_model_name.size > full_name.size
-            # TODO: why does this happen exactly??
-            full_name = model_class.full_model_name
-          end
-
-          if type.scoped_path_set? && foobara_registered?(full_name, mode: Namespace::LookupMode::DIRECT)
-            # :nocov:
-            raise AlreadyRegisteredError, "Already registered: #{type.inspect}"
-            # :nocov:
-          end
-
-          foobara_register(type)
-
-          type.target_class
-        end
-
         def foobara_register_and_deanonymize_entity(name, *, &)
           entity_class = foobara_register_entity(name, *, &)
           Foobara::Model.deanonymize_class(entity_class)

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

@@ -208,6 +208,7 @@ module Foobara
             delegates[attribute_name] = delegate_manifest
 
             delegated_type_declaration = model_type.type_at_path(data_path).reference_or_declaration_data
+            # TODO: add defaults and required for the delegated declaration!
             attributes(type: :attributes, element_type_declarations: { attribute_name => delegated_type_declaration })
 
             define_method attribute_name do

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/to_type_transformer.rb

@@ -118,7 +118,7 @@ module Foobara
 
                   model_class.description type.declaration_data[:description]
 
-                  domain.foobara_register_model(model_class)
+                  domain.foobara_register(type)
 
                   if type.declaration_data[:delegates]
                     model_class.delegate_attributes type.declaration_data[:delegates]

data/projects/model_attribute_helpers/src/attribute_helpers.rb

@@ -18,7 +18,7 @@ module Foobara
       # foobara_primary_key_type (nil if not an entity type)
       # foobara_associations
       module AttributeHelpers
-        include Foobara::Concern
+        include Concern
 
         module ClassMethods
           def foobara_has_primary_key?
@@ -46,15 +46,15 @@ module Foobara
 
             Namespace.use foobara_attributes_type.created_in_namespace do
               unless includes_primary_key
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+                declaration = TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
               end
 
               unless include_private
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *private_attribute_names)
+                declaration = TypeDeclarations::Attributes.reject(declaration, *private_attribute_names)
               end
 
               unless include_delegates
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *foobara_delegates.keys)
+                declaration = TypeDeclarations::Attributes.reject(declaration, *foobara_delegates.keys)
               end
 
               Domain.current.foobara_type_from_declaration(declaration)

data/projects/namespace/src/is_namespace.rb

@@ -181,7 +181,7 @@ module Foobara
 
           if candidates.size > 1
             # :nocov:
-            raise AmbiguousNameError,
+            raise AmbiguousLookupError,
                   "#{path} is ambiguous. Matches the following: #{candidates.map(&:scoped_full_name)}"
             # :nocov:
           end

data/projects/namespace/src/namespace/lookup_mode.rb

@@ -30,6 +30,12 @@ module Foobara
     # Maybe use bitmasks for the above 3 places to look instead of a list of 7 lookup types? (There should be 8...)
     module LookupMode
       GENERAL = :general
+      # Relaxed will allow you to find registered entries without prefixes as long as it's not ambiguous
+      # So if there is a SomeOrg::SomeDomain::SomeCommand `GlobalOrganization.foobara_lookup(:SomeCommand)`
+      # will return nil but
+      # `GlobalOrganization.foobara_lookup(:SomeCommand, mode: Foobara::Namespace::LookupMode::RELAXED)`
+      # will return SomeOrg::SomeDomain::SomeCommand even though we didn't specify the necessary prefixes
+      # to navigate to it.
       RELAXED = :relaxed
       DIRECT = :direct
       STRICT = :strict

data/projects/nested_transactionable/lib/foobara/nested_transactionable.rb

@@ -1,7 +1,5 @@
 module Foobara
   module NestedTransactionable
-    include Concern
-
     class << self
       def relevant_entity_classes_for_type(type)
         entity_classes = []

data/projects/persistence/src/entity_base/transaction/concerns/state_transitions.rb

@@ -7,8 +7,6 @@ module Foobara
 
         module Concerns
           module StateTransitions
-            foobara_delegate :close, to: :state_machine
-
             def currently_open?
               state_machine.currently_open?
             end

data/projects/persistence/src/entity_base.rb

@@ -188,6 +188,7 @@ module Foobara
           if tx.currently_open? && !existing_transaction
             tx.commit!
           end
+
           result
         rescue Foobara::Persistence::EntityBase::Transaction::RolledBack # rubocop:disable Lint/SuppressedException
         rescue => e

data/projects/type_declarations/lib/foobara/type_declarations.rb

@@ -46,8 +46,10 @@ module Foobara
           Namespace.global.foobara_register(scoped)
         end
 
+        children = Namespace.global.foobara_children
+
         @original_children.each do |child|
-          Namespace.global.foobara_children << child
+          children.foobara_children << child unless children.include?(child)
         end
 
         GlobalOrganization.foobara_register(GlobalDomain)

data/projects/type_declarations/src/remove_sensitive_values_transformer.rb

@@ -3,65 +3,6 @@ require_relative "typed_transformer"
 module Foobara
   module TypeDeclarations
     class RemoveSensitiveValuesTransformer < TypedTransformer
-      def from(...)
-        super.tap do
-          create_all_association_types_in_current_namespace(from_type)
-        end
-      end
-
-      def to(...)
-        super.tap do
-          create_all_association_types_in_current_namespace(to_type)
-        end
-      end
-
-      def create_all_association_types_in_current_namespace(type)
-        already_sanitized = Set.new
-
-        associations = Foobara::DetachedEntity.construct_deep_associations(type)
-
-        associations&.values&.reverse&.each do |entity_type|
-          next if already_sanitized.include?(entity_type)
-
-          next if entity_type.sensitive?
-
-          unless entity_type.has_sensitive_types?
-            already_sanitized << entity_type
-            next
-          end
-
-          ns = Namespace.current
-
-          declaration = entity_type.declaration_data
-          sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
-
-          existing_type = ns.foobara_lookup(
-            entity_type.full_type_symbol,
-            mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
-          )
-
-          if existing_type
-            if existing_type.declaration_data == sanitized_type_declaration
-              already_sanitized << entity_type
-              already_sanitized << existing_type
-              next
-            else
-              # :nocov:
-              raise "Did not expect to be re-sanitizing #{entity_type.full_type_symbol}"
-              # :nocov:
-            end
-
-          end
-
-          # We want to make sure that any types that change due to having sensitive types
-          # has a corresponding registered type in the command registry domain if needed
-          # TODO: this all feels so messy and brittle.
-          Domain.current.foobara_type_from_declaration(sanitized_type_declaration)
-
-          already_sanitized << entity_type
-        end
-      end
-
       def to_type_declaration
         TypeDeclarations.remove_sensitive_types(from_type.declaration_data)
       end

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.2.6".freeze
+    VERSION = "0.3.0".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.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Miles Georgi
@@ -190,6 +190,7 @@ files:
 - projects/command_connectors/src/command_connector/commands/ping.rb
 - projects/command_connectors/src/command_connector/commands/query_git_commit_info.rb
 - projects/command_connectors/src/command_connector/concerns/desugarizers.rb
+- projects/command_connectors/src/command_connector/concerns/reflection.rb
 - projects/command_connectors/src/command_connector/invalid_context_error.rb
 - projects/command_connectors/src/command_connector/no_command_found_error.rb
 - projects/command_connectors/src/command_connector/no_command_or_type_found_error.rb
@@ -274,6 +275,7 @@ files:
 - projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_is_symbol.rb
 - projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_present.rb
 - projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_references_attribute.rb
+- projects/detached_entity/src/remove_sensitive_values_transformer_extensions.rb
 - projects/detached_entity/src/sensitive_type_removers/detached_entity.rb
 - projects/detached_entity/src/sensitive_value_removers/detached_entity.rb
 - projects/domain/lib/foobara/domain.rb