foobara 0.3.0 → 0.4.2

data/projects/typesystem/projects/domain/src/module_extension.rb

@@ -0,0 +1,62 @@
+require "foobara/namespace"
+
+require_relative "organization_module_extension"
+require_relative "domain_module_extension"
+
+module Foobara
+  module Domain
+    # TODO: should we just couple domain project and commands project to simplify this connection?
+    # TODO: move this stuff to extensions/ directory
+    module ModuleExtension
+      class CannotBeOrganizationAndDomainAtSameTime < StandardError; end
+
+      def foobara_domain!
+        if foobara_organization?
+          # :nocov:
+          raise CannotBeOrganizationAndDomainAtSameTime
+          # :nocov:
+        end
+
+        unless is_a?(Namespace::IsNamespace)
+          foobara_namespace!
+          foobara_autoset_namespace!(default_namespace: Foobara::GlobalOrganization)
+          foobara_autoset_scoped_path!
+
+          foobara_parent_namespace.foobara_register(self)
+        end
+
+        include(DomainModuleExtension)
+      end
+
+      def foobara_organization!
+        if foobara_domain?
+          # :nocov:
+          raise CannotBeOrganizationAndDomainAtSameTime
+          # :nocov:
+        end
+
+        include(OrganizationModuleExtension)
+
+        unless is_a?(Namespace::IsNamespace)
+          foobara_namespace!
+          self.scoped_namespace = Namespace.global
+          foobara_autoset_scoped_path!(make_top_level: true)
+
+          foobara_parent_namespace.foobara_register(self)
+        end
+      end
+
+      def foobara_domain?
+        false
+      end
+
+      def foobara_organization?
+        false
+      end
+    end
+  end
+end
+
+Module.include(Foobara::Domain::ModuleExtension)
+
+Foobara.foobara_organization!

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

@@ -156,6 +156,7 @@ module Foobara
 
       def foobara_lookup(path, filter: nil, mode: LookupMode::GENERAL)
         LookupMode.validate!(mode)
+
         path = Namespace.to_registry_path(path)
 
         lru_cache.cached([self, path, mode, *filter]) do
@@ -189,6 +190,13 @@ module Foobara
           scoped = candidates.first ||
                    foobara_parent_namespace&.foobara_lookup_without_cache(path, filter:, mode:, visited:)
 
+          scoped ||= foobara_lookup_without_cache(
+            [*scoped_full_path, *path],
+            filter:,
+            mode: LookupMode::GENERAL,
+            visited:
+          )
+
           return scoped
         end
 

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,35 +15,26 @@ 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
 
-        if GlobalDomain.const_defined?(:Types, false)
-          GlobalDomain::Types.instance_variable_set(
-            :@foobara_lowercase_constants,
-            @original_foobara_lowercase_constants || []
-          )
-          GlobalDomain.send(:remove_const, :Types)
-        end
-
         @original_scoped.each do |scoped|
           Namespace.global.foobara_register(scoped)
         end
@@ -125,14 +118,9 @@ module Foobara
         # most important
         @original_scoped = Namespace.global.foobara_registry.all_scoped.dup
         @original_children = Namespace.global.foobara_children.dup
-
-        if GlobalDomain.const_defined?(:Types, false)
-          # :nocov:
-          @original_foobara_lowercase_constants =
-            GlobalDomain::Types.instance_variable_get(:@foobara_lowercase_constants).dup
-          # :nocov:
-        end
       end
     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.rb

@@ -38,19 +38,21 @@ module Foobara
     def handle_symbolic_declaration
       self.reference_checked = true
 
-      if declaration_data.is_a?(::Symbol)
-        symbol = declaration_data
-      elsif declaration_data.is_a?(::String) && TypeDeclarations.stringified?
-        symbol = declaration_data.to_sym
-      end
+      symbol = if declaration_data.is_a?(::Symbol)
+                 declaration_data
+               elsif declaration_data.is_a?(::String)
+                 declaration_data.to_sym
+               end
 
       if symbol
-        type = if absolutified?
-                 Domain.current.foobara_lookup_type(symbol, mode: Namespace::LookupMode::ABSOLUTE)
+        mode = if absolutified?
+                 Namespace::LookupMode::ABSOLUTE
                else
-                 Domain.current.foobara_lookup_type(symbol)
+                 Namespace::LookupMode::RELAXED
                end
 
+        type = Domain.current.foobara_lookup_type(symbol, mode:)
+
         if type
           unless strict?
             self.declaration_data = type.full_type_symbol
@@ -61,7 +63,6 @@ module Foobara
           self.is_strict = true
           self.is_deep_duped = true
           self.is_duped = true
-
         else
           if declaration_data.is_a?(::Symbol)
             self.is_duped = true
@@ -93,12 +94,14 @@ module Foobara
 
         if type_symbol
           if type_symbol.is_a?(::Symbol) || type_symbol.is_a?(::String)
-            type = if absolutified?
-                     Domain.current.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
+            mode = if absolutified?
+                     Namespace::LookupMode::ABSOLUTE
                    else
-                     Domain.current.foobara_lookup_type(type_symbol)
+                     Namespace::LookupMode::RELAXED
                    end
 
+            type = Domain.current.foobara_lookup_type(type_symbol, mode:)
+
             if type
               symbolize_keys!
               self[:type] = type.full_type_symbol

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/typed_transformer.rb

@@ -1,8 +1,19 @@
 module Foobara
   module TypeDeclarations
     # TODO: this should instead be a processor and have its own possible_errors
+    # TODO: does it make sense that this is in this project? Seems to be more generic than TypeDeclarations
     class TypedTransformer < Value::Transformer
       class << self
+        def subclass(to: nil, from: nil, &map_proc)
+          klass = Class.new(self)
+
+          klass.to(to) if to
+          klass.from(from) if from
+          klass.define_method(:transform, &map_proc) if map_proc
+
+          klass
+        end
+
         def requires_declaration_data?
           false
         end
@@ -66,8 +77,8 @@ module Foobara
         @to_type = Domain.current.foobara_type_from_declaration(...)
       end
 
-      def initialize(from: nil, to: nil)
-        super()
+      def initialize(from: nil, to: nil, **)
+        super(**)
 
         if from
           self.from from

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

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

@@ -9,3 +9,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("types", project_path: "#{__dir__}/../..")

data/projects/{types → typesystem/projects/types}/src/type/concerns/supported_processor_registration.rb

@@ -1,3 +1,5 @@
+require "foobara/value"
+
 module Foobara
   module Types
     class Type < Value::Processor::Pipeline