foobara 0.2.7 → 0.4.1

data/projects/command_connectors/src/command_registry.rb

@@ -32,45 +32,11 @@ module Foobara
       create_exposed_command(command_class, **)
     end
 
-    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_SINGLE_NAMESPACE) ||
-                       build_and_register_exposed_domain(full_domain_name)
-
-      exposed_command = create_exposed_command_without_domain(command_class, **)
-
-      exposed_domain.foobara_register(exposed_command)
-
-      exposed_command
-    end
-
     # TODO: eliminate this method
     def create_exposed_command_without_domain(command_class, **)
       ExposedCommand.new(command_class, **apply_defaults(**))
     end
 
-    def apply_defaults(
-      inputs_transformers: nil,
-      result_transformers: nil,
-      errors_transformers: nil,
-      pre_commit_transformers: nil,
-      serializers: nil,
-      allowed_rule: default_allowed_rule,
-      authenticator: nil,
-      **opts
-    )
-      opts.merge(
-        inputs_transformers: [*inputs_transformers, *default_inputs_transformers],
-        result_transformers: [*result_transformers, *default_result_transformers],
-        errors_transformers: [*errors_transformers, *default_errors_transformers],
-        pre_commit_transformers: [*pre_commit_transformers, *default_pre_commit_transformers],
-        serializers: [*serializers, *default_serializers],
-        allowed_rule: allowed_rule && to_allowed_rule(allowed_rule),
-        authenticator: authenticator || self.authenticator
-      )
-    end
-
     def build_and_register_exposed_domain(domain_full_name)
       domain_module = if domain_full_name.to_s == ""
                         GlobalDomain
@@ -211,6 +177,37 @@ module Foobara
       default_serializers << serializer
     end
 
+    def transformed_command_from_name(name)
+      foobara_lookup_command(name, mode: Namespace::LookupMode::RELAXED)&.transformed_command_class
+    end
+
+    def all_transformed_command_classes
+      foobara_all_command.map(&:transformed_command_class)
+    end
+
+    def each_transformed_command_class(&)
+      foobara_all_command.map(&:transformed_command_class).each(&)
+    end
+
+    def size
+      foobara_all_command.size
+    end
+
+    private
+
+    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_SINGLE_NAMESPACE) ||
+                       build_and_register_exposed_domain(full_domain_name)
+
+      exposed_command = create_exposed_command_without_domain(command_class, **)
+
+      exposed_domain.foobara_register(exposed_command)
+
+      exposed_command
+    end
+
     def to_allowed_rule(*args)
       symbol, object = case args.size
                        when 1
@@ -289,20 +286,25 @@ module Foobara
       end
     end
 
-    def transformed_command_from_name(name)
-      foobara_lookup_command(name, mode: Namespace::LookupMode::RELAXED)&.transformed_command_class
-    end
-
-    def all_transformed_command_classes
-      foobara_all_command.map(&:transformed_command_class)
-    end
-
-    def each_transformed_command_class(&)
-      foobara_all_command.map(&:transformed_command_class).each(&)
-    end
-
-    def size
-      foobara_all_command.size
+    def apply_defaults(
+      inputs_transformers: nil,
+      result_transformers: nil,
+      errors_transformers: nil,
+      pre_commit_transformers: nil,
+      serializers: nil,
+      allowed_rule: default_allowed_rule,
+      authenticator: nil,
+      **opts
+    )
+      opts.merge(
+        inputs_transformers: [*inputs_transformers, *default_inputs_transformers],
+        result_transformers: [*result_transformers, *default_result_transformers],
+        errors_transformers: [*errors_transformers, *default_errors_transformers],
+        pre_commit_transformers: [*pre_commit_transformers, *default_pre_commit_transformers],
+        serializers: [*serializers, *default_serializers],
+        allowed_rule: allowed_rule && to_allowed_rule(allowed_rule),
+        authenticator: authenticator || self.authenticator
+      )
     end
   end
 end

data/projects/command_connectors/src/transformed_command.rb

@@ -61,7 +61,17 @@ module Foobara
         end
       end
 
-      foobara_delegate :domain, :organization, to: :command_class
+      def domain
+        # :nocov:
+        command_class.domain
+        # :nocov:
+      end
+
+      def organization
+        # :nocov:
+        command_class.organization
+        # :nocov:
+      end
 
       def description
         command_class.description
@@ -425,52 +435,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 +545,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
@@ -592,19 +604,57 @@ module Foobara
       construct_command
     end
 
-    foobara_delegate :description, to: :command_class
-    foobara_delegate :full_command_name,
-                     :command_name,
-                     :command_class,
-                     :capture_unknown_error,
-                     :inputs_transformers,
-                     :result_transformers,
-                     :errors_transformers,
-                     :pre_commit_transformers,
-                     :serializers,
-                     :allowed_rule,
-                     :authenticator,
-                     to: :class
+    def full_command_name
+      # :nocov:
+      self.class.full_command_name
+      # :nocov:
+    end
+
+    def command_name
+      # :nocov:
+      self.class.command_name
+      # :nocov:
+    end
+
+    def command_class
+      self.class.command_class
+    end
+
+    def capture_unknown_error
+      self.class.capture_unknown_error
+    end
+
+    def inputs_transformers
+      # :nocov:
+      self.class.inputs_transformers
+      # :nocov:
+    end
+
+    def result_transformers
+      # :nocov:
+      self.class.result_transformers
+      # :nocov:
+    end
+
+    def errors_transformers
+      self.class.errors_transformers
+    end
+
+    def pre_commit_transformers
+      self.class.pre_commit_transformers
+    end
+
+    def serializers
+      self.class.serializers
+    end
+
+    def allowed_rule
+      self.class.allowed_rule
+    end
+
+    def authenticator
+      self.class.authenticator
+    end
 
     def run
       apply_allowed_rule
@@ -626,23 +676,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 +760,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 +891,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 +900,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/domain_mapper/lib/foobara/domain_mapper.rb

@@ -1,3 +1,5 @@
+require "foobara/command"
+
 module Foobara
   class DomainMapper
     class << self
@@ -8,3 +10,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("domain_mapper", project_path: "#{__dir__}/../..")

data/projects/domain_mapper/src/domain_mapper.rb

@@ -52,6 +52,8 @@ module Foobara
         [*match_score(from_type, from_value), *match_score(to_type, to_value)].sum
       end
 
+      private
+
       def match_score(type_indicator, value)
         return 1 if type_indicator.nil? || value.nil?
         return 20 if type_indicator == value

data/projects/{detached_entity → entities/projects/detached_entity}/lib/foobara/detached_entity.rb

@@ -1,3 +1,5 @@
+require "foobara/model"
+
 module Foobara
   class DetachedEntity < Model
     abstract
@@ -24,3 +26,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("detached_entity", project_path: "#{__dir__}/../..")

data/projects/{detached_entity → entities/projects/detached_entity}/src/concerns/primary_key.rb

@@ -4,7 +4,9 @@ module Foobara
       module PrimaryKey
         include Concern
 
-        foobara_delegate :primary_key_attribute, to: :class
+        def primary_key_attribute
+          self.class.primary_key_attribute
+        end
 
         module ClassMethods
           def primary_key(attribute_name)

data/projects/{detached_entity → entities/projects/detached_entity}/src/concerns/types.rb

@@ -4,7 +4,15 @@ module Foobara
       module Types
         include Concern
 
-        foobara_delegate :full_entity_name, :entity_name, to: :class
+        def full_entity_name
+          # :nocov:
+          self.class.full_entity_name
+          # :nocov:
+        end
+
+        def entity_name
+          self.class.entity_name
+        end
 
         module ClassMethods
           def entity_type

data/projects/{detached_entity → entities/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 == expected_type_symbol
+            return EMPTY_ARRAY 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/{entity → entities/projects/entity}/lib/foobara/entity.rb

@@ -1,3 +1,5 @@
+require "foobara/detached_entity"
+
 module Foobara
   # TODO: I think we should have a configuration that indicates if created records can have primary keys passed to them
   # or not. That is, do primary keys get issued by the database upon insertion? Or are they generated externally
@@ -29,3 +31,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("entity", project_path: "#{__dir__}/../..")

data/projects/{entity → entities/projects/entity}/src/concerns/callbacks.rb

@@ -1,3 +1,5 @@
+require "foobara/callback"
+
 module Foobara
   class Entity < DetachedEntity
     module Concerns

data/projects/{entity → entities/projects/entity}/src/concerns/transactions.rb

@@ -17,11 +17,7 @@ module Foobara
             if skip_dependent_transactions
               entity_base.transaction(mode, &)
             else
-              Foobara::Persistence.transaction(
-                self, *deep_depends_on,
-                mode:,
-                &
-              )
+              Foobara::Persistence.transaction(self, *deep_depends_on, mode:, &)
             end
           end
         end

data/projects/entities/projects/entity/src/extensions/domain/domain_module_extension.rb

@@ -0,0 +1,111 @@
+module Foobara
+  module Domain
+    module DomainModuleExtension
+      module ClassMethods
+        attr_reader :foobara_default_entity_base
+
+        def foobara_set_entity_base(*, name: nil, table_prefix: nil)
+          name ||= Util.underscore(scoped_full_name).gsub("::", "_")
+          base = Persistence.register_base(*, name:, table_prefix:)
+          @foobara_default_entity_base = base
+        end
+
+        def foobara_register_and_deanonymize_entity(name, *, &)
+          entity_class = foobara_register_entity(name, *, &)
+          Foobara::Model.deanonymize_class(entity_class)
+        end
+
+        # TODO: kill this off
+        def foobara_register_entity(name, *args, &block)
+          # 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).declaration_data,
+                *args
+              ]
+            end
+
+            attributes_type_declaration, *args = args
+
+            model_base_class, description = case args.size
+                                            when 0
+                                              []
+                                            when 1, 2
+                                              arg, other = args
+
+                                              if args.first.is_a?(::String)
+                                                [other, arg]
+                                              else
+                                                args
+                                              end
+                                            else
+                                              # :nocov:
+                                              raise ArgumentError, "Too many arguments"
+                                              # :nocov:
+                                            end
+
+            if model_base_class
+              attributes_type_declaration = TypeDeclarations::Attributes.merge(
+                model_base_class.attributes_type.declaration_data,
+                attributes_type_declaration
+              )
+            end
+
+            handler = foobara_type_builder.handler_for_class(
+              Foobara::TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+            )
+
+            attributes_type = handler.type_for_declaration(attributes_type_declaration)
+
+            # TODO: reuse the model_base_class primary key if it has one...
+            primary_key = attributes_type.element_types.keys.first
+
+            model_module = unless scoped_full_path.empty?
+                             scoped_full_name
+                           end
+
+            declaration = TypeDeclaration.new(
+              Util.remove_blank(
+                type: :entity,
+                name:,
+                model_base_class:,
+                model_module:,
+                attributes_declaration: attributes_type_declaration,
+                primary_key:,
+                description:
+              )
+            )
+
+            declaration.is_absolutified = true
+            declaration.is_duped = true
+
+            entity_type = foobara_type_builder.type_for_declaration(declaration)
+
+            entity_type.target_class
+          end
+        end
+
+        def foobara_register_and_deanonymize_entities(entity_names_to_attributes)
+          entities = []
+
+          entity_names_to_attributes.each_pair do |entity_name, attributes_declaration|
+            entities << foobara_register_and_deanonymize_entity(entity_name, attributes_declaration)
+          end
+
+          entities
+        end
+
+        def foobara_register_entities(entity_names_to_attributes)
+          entities = []
+
+          entity_names_to_attributes.each_pair do |entity_name, attributes_type_declaration|
+            entities << foobara_register_entity(entity_name, attributes_type_declaration)
+          end
+
+          entities
+        end
+      end
+    end
+  end
+end