foobara 0.2.7 → 0.4.1

data/projects/{domain → typesystem/projects/domain}/src/domain_module_extension.rb

@@ -11,43 +11,6 @@ module Foobara
     end
 
     module DomainModuleExtension
-      class << self
-        # TODO: rename this
-        def _copy_constants(old_mod, new_class)
-          old_mod.constants.each do |const_name|
-            value = old_mod.const_get(const_name)
-            if new_class.const_defined?(const_name)
-              # TODO: figure out how to test this path. Seems to occur when models are nested and loaded
-              # remotely in a certain order
-              # :nocov:
-              to_replace = new_class.const_get(const_name)
-              if to_replace != value
-                new_class.send(:remove_const, const_name)
-                new_class.const_set(const_name, value)
-              end
-              # :nocov:
-            else
-              new_class.const_set(const_name, value)
-            end
-          end
-
-          lower_case_constants = old_mod.instance_variable_get(:@foobara_lowercase_constants)
-
-          if lower_case_constants && !lower_case_constants.empty?
-            lower_case_constants&.each do |lower_case_constant|
-              new_class.singleton_class.define_method lower_case_constant do
-                old_mod.send(lower_case_constant)
-              end
-            end
-
-            new_lowercase_constants = new_class.instance_variable_get(:@foobara_lowercase_constants) || []
-            new_lowercase_constants += lower_case_constants
-
-            new_class.instance_variable_set(:@foobara_lowercase_constants, new_lowercase_constants)
-          end
-        end
-      end
-
       include Concern
       include Manifestable
 
@@ -96,7 +59,6 @@ module Foobara
                   child = Object.const_get(child_name)
 
                   break if child.foobara_domain?
-
                   break if child.foobara_organization?
 
                   # TODO: unclear why we need this check, hmmm, figure it out and document it (or delete if not needed)
@@ -105,9 +67,7 @@ module Foobara
                     # in .reset_alls hmmmmmm...
                     # :nocov:
                     value = child.const_get(constant)
-
-                    # TODO: can we make this not coupled to model project??
-                    value.is_a?(Types::Type) || (value.is_a?(::Class) && value < Foobara::Model)
+                    value.is_a?(Types::Type) || (value.is_a?(::Class) && value.respond_to?(:foobara_type?))
                     # :nocov:
                   end
 
@@ -245,10 +205,6 @@ module Foobara
           end
         end
 
-        def foobara_command_classes
-          foobara_all_command(mode: Namespace::LookupMode::DIRECT)
-        end
-
         def foobara_register_type(type_symbol, *type_declaration_bits, &block)
           type = if block.nil? && type_declaration_bits.size == 1 && type_declaration_bits.first.is_a?(Types::Type)
                    type_declaration_bits.first
@@ -310,107 +266,6 @@ module Foobara
           type
         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
-
-        def foobara_can_call_subcommands_from?(other_domain)
-          other_domain = Domain.to_domain(other_domain)
-          other_domain == self || self == GlobalDomain || foobara_depends_on?(other_domain)
-        end
-
         def foobara_depends_on?(other_domain)
           other_domain = Domain.to_domain(other_domain)
           other_domain == GlobalDomain || foobara_depends_on.include?(other_domain.foobara_full_domain_name)
@@ -455,13 +310,6 @@ module Foobara
             domain.foobara_manifest_reference
           end.sort
 
-          commands = foobara_all_command(mode: Namespace::LookupMode::DIRECT).map do |command_class|
-            if to_include
-              to_include << command_class
-            end
-            command_class.foobara_manifest_reference
-          end.sort
-
           types = foobara_all_type(mode: Namespace::LookupMode::DIRECT).map do |type|
             if to_include
               to_include << type
@@ -469,7 +317,7 @@ module Foobara
             type.foobara_manifest_reference
           end.sort
 
-          manifest = super.merge(commands:, types:)
+          manifest = super.merge(types:)
 
           unless depends_on.empty?
             manifest[:depends_on] = depends_on
@@ -478,6 +326,8 @@ module Foobara
           manifest
         end
 
+        private
+
         def _set_type_constant(type)
           domain = if scoped_full_path.empty?
                      GlobalDomain
@@ -534,7 +384,7 @@ module Foobara
                 types_mod.send(:remove_const, type.scoped_short_name)
                 types_mod.const_set(type.scoped_short_name, type.target_class)
 
-                DomainModuleExtension._copy_constants(existing_value, type.target_class)
+                Domain.copy_constants(existing_value, type.target_class)
               else
                 # :nocov:
                 raise CannotSetTypeConstantError,

data/projects/{domain → typesystem/projects/domain}/src/extensions/foobara.rb

@@ -1,11 +1,5 @@
 module Foobara
   class << self
-    # TODO: come up with a way to change a type's manifest... Or maybe treat Model very differently?
-    # ok... new manifest will be of this form...
-    # { <orgs|commands|types, etc, letś call this a type category...> => full_scoped_name => manifest }
-    #
-    # The manifest itself will only contain full scoped names. This is kind of analogous to a store serializer
-    # in the http connector.
     def manifest
       to_include = Namespace.global.foobara_all_organization.to_set
 
@@ -61,10 +55,6 @@ module Foobara
       Namespace.global.foobara_all_domain
     end
 
-    def all_commands
-      Namespace.global.foobara_all_command
-    end
-
     def all_types
       Namespace.global.foobara_all_type
     end

data/projects/{domain → typesystem/projects/domain}/src/global_domain.rb

@@ -6,6 +6,7 @@ module Foobara
     GlobalOrganization.foobara_register(self)
 
     foobara_domain!
+
     self.foobara_domain_name = "global_domain"
     self.foobara_full_domain_name = "#{GlobalOrganization.foobara_organization_name}::#{foobara_domain_name}"
     self.foobara_manifest_reference = foobara_full_domain_name

data/projects/{domain → typesystem/projects/domain}/src/global_organization.rb

@@ -6,6 +6,7 @@ module Foobara
     Namespace.global.foobara_register(self)
 
     foobara_organization!
+
     self.foobara_manifest_reference = self.foobara_organization_name = "global_organization"
   end
 end

data/projects/{domain → typesystem/projects/domain}/src/is_manifestable.rb

@@ -8,6 +8,7 @@ module Foobara
       ].each do |variable|
         remove_instance_variable(variable) if instance_variable_defined?(variable)
       end
+
       super
     end
 

data/projects/{domain → typesystem/projects/domain}/src/manifestable.rb

@@ -1,4 +1,5 @@
 require_relative "is_manifestable"
+require "foobara/concerns"
 
 module Foobara
   # Weird that this concept lives here instead of in its own project...

data/projects/{domain → typesystem/projects/domain}/src/module_extension.rb

@@ -1,3 +1,5 @@
+require "foobara/namespace"
+
 require_relative "organization_module_extension"
 require_relative "domain_module_extension"
 
@@ -67,16 +69,8 @@ module Foobara
 
             if value != child
               types_mod.send(:remove_const, child.scoped_short_name) if value
-              # TODO: can we decouple this from the model project?
-              new_value = if child.extends?("::model")
-                            child.target_class
-                          else
-                            # TODO: test this path or delete it if unreachable
-                            # :nocov:
-                            child
-                            # :nocov:
-                          end
-              types_mod.const_set(child.scoped_short_name, new_value)
+
+              foobara_set_types_mod_constant(types_mod, child.scoped_short_name, child)
             end
           end
         end
@@ -107,6 +101,16 @@ module Foobara
       def foobara_organization?
         false
       end
+
+      private
+
+      # Unclear if we actually need this but putting it here to allow entities project
+      # to override this to set the constant to the target class
+      def foobara_set_types_mod_constant(types_mod, name, value)
+        # :nocov:
+        types_mod.const_set(types_mod, name, value)
+        # :nocov:
+      end
     end
   end
 end

data/projects/typesystem/projects/enumerated/lib/foobara/enumerated.rb

@@ -0,0 +1,3 @@
+module Foobara::Enumerated; end
+
+Foobara.project("enumerated", project_path: "#{__dir__}/../..")

data/projects/{enumerated → typesystem/projects/enumerated}/src/accessors.rb

@@ -1,3 +1,5 @@
+require "foobara/concerns"
+
 module Foobara
   module Enumerated
     module Accessors

data/projects/typesystem/projects/namespace/lib/foobara/namespace.rb

@@ -0,0 +1,6 @@
+module Foobara
+  class Namespace
+  end
+end
+
+Foobara.project("namespace", project_path: "#{__dir__}/../..")

data/projects/{namespace → typesystem/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 → typesystem/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/{namespace → typesystem/projects/namespace}/src/namespace.rb

@@ -1,3 +1,5 @@
+require "foobara/lru_cache"
+
 module Foobara
   class Namespace
     include IsNamespace

data/projects/{namespace → typesystem/projects/namespace}/src/namespace_helpers.rb

@@ -1,4 +1,5 @@
 require_relative "is_namespace"
+require "foobara/concerns"
 
 module Foobara
   class Namespace

data/projects/typesystem/projects/project/lib/foobara/project.rb

@@ -0,0 +1,10 @@
+require "foobara/util"
+
+module Foobara
+  class Project; end
+end
+
+Foobara::Util.require_directory "#{__dir__}/../../src"
+
+# Do we need this to be a project??
+Foobara.project("project", project_path: "#{__dir__}/../..")

data/projects/{foobara → typesystem/projects/project}/src/foobara.rb

@@ -4,6 +4,7 @@ module Foobara
   class MethodCantBeCalledInProductionError < StandardError; end
 
   class << self
+    # TODO: let's eliminate this method
     def require_project_file(project, path)
       # :nocov:
       warn "DEPRECATION WARNING: require_project_file is deprecated. Use require_relative instead."
@@ -17,12 +18,6 @@ module Foobara
       @all_projects ||= {}
     end
 
-    def projects(*symbols)
-      symbols.each do |symbol|
-        project(symbol)
-      end
-    end
-
     def project(symbol, project_path: nil)
       if all_projects.key?(symbol)
         # :nocov:

data/projects/{foobara → typesystem/projects/project}/src/project.rb

@@ -21,7 +21,9 @@ module Foobara
 
     def load
       require require_path
+
       src_dir = "#{project_path}/src"
+
       if Dir.exist?(src_dir)
         Util.require_directory(src_dir)
       end
@@ -35,6 +37,7 @@ module Foobara
 
     def reset_all
       Foobara.raise_if_production!("reset_all")
+
       if self.module.respond_to?(:reset_all)
         self.module.reset_all
       end

data/projects/typesystem/projects/state_machine/lib/foobara/state_machine.rb

@@ -0,0 +1,3 @@
+class Foobara::StateMachine; end
+
+Foobara.project("state_machine", project_path: "#{__dir__}/../..")

data/projects/{state_machine → typesystem/projects/state_machine}/src/callbacks.rb

@@ -1,3 +1,5 @@
+require "foobara/callback"
+
 module Foobara
   class StateMachine
     module Callbacks
@@ -9,14 +11,41 @@ module Foobara
         self.callback_registry = Callback::Registry::ChainedConditioned.new(self.class.class_callback_registry)
       end
 
-      foobara_delegate :callbacks_for,
-                       :has_callbacks?,
-                       :has_before_callbacks?,
-                       :has_after_callbacks?,
-                       :has_around_callbacks?,
-                       :has_error_callbacks?,
-                       :has_failure_callbacks?,
-                       to: :callback_registry
+      def callbacks_for(*, **)
+        # :nocov:
+        callback_registry.callbacks_for(*, **)
+        # :nocov:
+      end
+
+      def has_callbacks?(*, **)
+        # :nocov:
+        callback_registry.has_callbacks?(*, **)
+        # :nocov:
+      end
+
+      def has_before_callbacks?(*, **)
+        # :nocov:
+        callback_registry.has_before_callbacks?(*, **)
+        # :nocov:
+      end
+
+      def has_after_callbacks?(*, **)
+        # :nocov:
+        callback_registry.has_after_callbacks?(*, **)
+        # :nocov:
+      end
+
+      def has_around_callbacks?(*, **)
+        # :nocov:
+        callback_registry.has_around_callbacks?(*, **)
+        # :nocov:
+      end
+
+      def has_error_callbacks?(*, **)
+        # :nocov:
+        callback_registry.has_error_callbacks?(*, **)
+        # :nocov:
+      end
 
       def register_transition_callback(type, **, &)
         callback_registry.register_callback(type, **, &)

data/projects/{state_machine → typesystem/projects/state_machine}/src/sugar.rb

@@ -1,3 +1,5 @@
+require "foobara/enumerated"
+
 module Foobara
   class StateMachine
     module Sugar

data/projects/{state_machine → typesystem/projects/state_machine}/src/transition_log.rb

@@ -1,3 +1,5 @@
+require "foobara/concerns"
+
 module Foobara
   class StateMachine
     module TransitionLog

data/projects/{type_declarations → typesystem/projects/type_declarations}/lib/foobara/type_declarations.rb

@@ -1,3 +1,5 @@
+require "foobara/types"
+
 module Foobara
   module TypeDeclarations
     class << self
@@ -13,24 +15,23 @@ module Foobara
         end
 
         [
-          "foobara_children",
-          "foobara_registry",
-          "foobara_type_builder"
+          :@foobara_children,
+          :@foobara_registry,
+          :@foobara_type_builder
         ].each do |var_name|
-          var_name = "@#{var_name}"
-
           # Don't we only have to do this for Foobara and not all of these??
           [
             Namespace.global,
             Foobara::GlobalOrganization,
             Foobara::GlobalDomain,
             Domain,
-            Command,
             Types::Type,
             Value::Processor,
             Error
           ].each do |klass|
-            klass.remove_instance_variable(var_name) if klass.instance_variable_defined?(var_name)
+            if klass.instance_variable_defined?(var_name)
+              klass.remove_instance_variable(var_name)
+            end
           end
         end
 
@@ -136,3 +137,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("type_declarations", project_path: "#{__dir__}/../..")

data/projects/{type_declarations → typesystem/projects/type_declarations}/src/dsl/attributes.rb

@@ -45,6 +45,8 @@ module Foobara
 
         attr_accessor :_method_missing_disabled
 
+        # Underscores are used in this class to free up more potential attribute names
+        # by assuming they generally won't start with _ in real use.
         def _to_declaration(&)
           instance_exec(&)
           _type_declaration

data/projects/{type_declarations → typesystem/projects/type_declarations}/src/error_extension.rb

@@ -67,7 +67,15 @@ module Foobara
         end
       end
 
-      foobara_delegate :context_type, :context_type_declaration, to: :class
+      def context_type
+        self.class.context_type
+      end
+
+      def context_type_declaration
+        # :nocov:
+        self.class.context_type_declaration
+        # :nocov:
+      end
     end
   end
 end

data/projects/{type_declarations → typesystem/projects/type_declarations}/src/lazy_element_types/array.rb

@@ -2,6 +2,8 @@ module Foobara
   module TypeDeclarations
     module LazyElementTypes
       module Array
+        # TODO: change this to class << self?
+
         module_function
 
         def resolve(type)

data/projects/{type_declarations → typesystem/projects/type_declarations}/src/type_declaration_handler.rb

@@ -1,3 +1,5 @@
+require "foobara/value"
+
 require_relative "with_registries"
 
 module Foobara
@@ -60,11 +62,25 @@ module Foobara
         super(*Util.args_and_opts_to_args(args, opts))
       end
 
-      foobara_delegate :starting_desugarizers,
-                       :starting_desugarizers_with_inherited,
-                       :starting_desugarizers_without_inherited,
-                       :starting_type_declaration_validators,
-                       to: :class
+      def starting_desugarizers
+        self.class.starting_desugarizers
+      end
+
+      def starting_desugarizers_with_inherited
+        # :nocov:
+        self.class.starting_desugarizers_with_inherited
+        # :nocov:
+      end
+
+      def starting_desugarizers_without_inherited
+        # :nocov:
+        self.class.starting_desugarizers_without_inherited
+        # :nocov:
+      end
+
+      def starting_type_declaration_validators
+        self.class.starting_type_declaration_validators
+      end
 
       def to_type_transformer
         self.class::ToTypeTransformer.instance

data/projects/{type_declarations → typesystem/projects/type_declarations}/src/with_registries.rb

@@ -1,3 +1,5 @@
+require "foobara/concerns"
+
 module Foobara
   module TypeDeclarations
     module WithRegistries
@@ -29,14 +31,35 @@ module Foobara
         end
       end
 
-      foobara_delegate :type_for_declaration,
-                       :type_declaration_handler_for,
-                       :lookup_type,
-                       :lookup_type!,
-                       :lookup_absolute_type!,
-                       :type_registered?,
-                       :handler_for_class,
-                       to: :class
+      def type_for_declaration(...)
+        self.class.type_for_declaration(...)
+      end
+
+      def type_declaration_handler_for(...)
+        self.class.type_declaration_handler_for(...)
+      end
+
+      def lookup_type(...)
+        self.class.lookup_type(...)
+      end
+
+      def lookup_type!(...)
+        self.class.lookup_type!(...)
+      end
+
+      def lookup_absolute_type!(...)
+        # :nocov:
+        self.class.lookup_absolute_type!(...)
+        # :nocov:
+      end
+
+      def type_registered?(...)
+        self.class.type_registered?(...)
+      end
+
+      def handler_for_class(...)
+        self.class.handler_for_class(...)
+      end
     end
   end
 end