foobara 0.3.0 → 0.4.2

data/projects/manifest/src/{foobara/manifest/type.rb → type.rb}

@@ -10,11 +10,11 @@ module Foobara
 
           if self == Type
             if type.entity?
-              type = Entity.new(type.root_manifest, type.path)
+              type = Entity.new(type.root_manifest, type.manifest_path)
             elsif type.detached_entity?
-              type = DetachedEntity.new(type.root_manifest, type.path)
+              type = DetachedEntity.new(type.root_manifest, type.manifest_path)
             elsif type.model?
-              type = Model.new(type.root_manifest, type.path)
+              type = Model.new(type.root_manifest, type.manifest_path)
             end
           end
 
@@ -105,7 +105,7 @@ module Foobara
       end
 
       def to_type_declaration_from_declaration_data
-        TypeDeclaration.new(root_manifest, [*path, :declaration_data])
+        TypeDeclaration.new(root_manifest, [*manifest_path, :declaration_data])
       end
     end
   end

data/projects/manifest/src/{foobara/manifest/type_declaration.rb → type_declaration.rb}

@@ -12,9 +12,9 @@ module Foobara
           if self == TypeDeclaration
             case type_declaration.type.to_sym
             when :attributes
-              Attributes.new(type_declaration.root_manifest, type_declaration.path)
+              Attributes.new(type_declaration.root_manifest, type_declaration.manifest_path)
             when :array
-              Array.new(type_declaration.root_manifest, type_declaration.path)
+              Array.new(type_declaration.root_manifest, type_declaration.manifest_path)
             else
               type_declaration
             end
@@ -37,7 +37,7 @@ module Foobara
       def attribute?
         return @is_attribute if defined?(@is_attribute)
 
-        parent_path_atom = path[2..][-2]
+        parent_path_atom = manifest_path[2..][-2]
         @is_attribute = [:element_type_declarations, "element_type_declarations"].include?(parent_path_atom)
       end
       # rubocop:enable Naming/MemoizedInstanceVariableName
@@ -47,7 +47,7 @@ module Foobara
 
         raise "Not an attribute" unless attribute?
 
-        @parent_attributes = Attributes.new(root_manifest, path[0..-3])
+        @parent_attributes = Attributes.new(root_manifest, manifest_path[0..-3])
       end
 
       def attribute_name
@@ -55,7 +55,7 @@ module Foobara
 
         raise "Not an attribute" unless attribute?
 
-        @attribute_name = path[-1]
+        @attribute_name = manifest_path[-1]
       end
 
       def required?

data/projects/model_plumbing/lib/foobara/model_plumbing.rb

@@ -0,0 +1,13 @@
+module Foobara
+  module ModelPlumbing
+    class << self
+      def install!
+        Model.on_reregister do
+          GlobalDomain.foobara_each_command(&:handle_reregistered_types!)
+        end
+      end
+    end
+  end
+end
+
+Foobara.project("model_plumbing", project_path: "#{__dir__}/../..")

data/projects/{namespace/lib/foobara/namespace.rb → model_plumbing/src/model_plumbing.rb}

@@ -1,4 +1,4 @@
 module Foobara
-  class Namespace
+  module ModelPlumbing
   end
 end

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

@@ -1,3 +1,5 @@
+require "foobara/type_declarations"
+
 require "date"
 require "time"
 require "bigdecimal"
@@ -82,3 +84,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("builtin_types", project_path: "#{__dir__}/../..")

data/projects/{builtin_types → typesystem/projects/builtin_types}/src/builtin_types.rb

@@ -25,7 +25,7 @@ module Foobara
         casters_module = Util.constant_value(builtin_type_module, :Casters)
         caster_classes = if casters_module
                            Util.constant_values(casters_module, extends: Value::Processor)
-                         end
+                         end&.sort_by(&:name)
         casters = []
         caster_classes&.each do |caster_class|
           if caster_class.respond_to?(:requires_type?) && caster_class.requires_type?
@@ -154,12 +154,6 @@ module Foobara
         type
       end
 
-      private
-
-      def global_type_declaration_handler_registry
-        TypeDeclarations.global_type_declaration_handler_registry
-      end
-
       def install_type_declaration_extensions_for(processor_class)
         extension_module = Util.constant_value(processor_class, :TypeDeclarationExtension)
 
@@ -210,6 +204,12 @@ module Foobara
           end
         end
       end
+
+      private
+
+      def global_type_declaration_handler_registry
+        TypeDeclarations.global_type_declaration_handler_registry
+      end
     end
   end
 end

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

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

data/projects/{callback → typesystem/projects/callback}/src/block/concerns/type.rb

@@ -1,3 +1,5 @@
+require "foobara/concerns"
+
 module Foobara
   module Callback
     class Block

data/projects/{callback → typesystem/projects/callback}/src/set.rb

@@ -11,7 +11,9 @@ module Foobara
         end
       end
 
-      foobara_delegate :size, to: :callbacks
+      def size
+        callbacks.size
+      end
 
       def union(set)
         unioned = Set.new(callbacks)

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

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

data/projects/{common → typesystem/projects/common}/src/data_path.rb

@@ -5,7 +5,7 @@ module Foobara
     class BadPathError < StandardError; end
 
     # TODO: use this wherever it makes sense
-    EMPTY_PATH = [].freeze
+    EMPTY_PATH = EMPTY_ARRAY
 
     class TooManyValuesAtPathError < StandardError
       attr_accessor :path, :values

data/projects/{common → typesystem/projects/common}/src/error.rb

@@ -1,3 +1,5 @@
+require "foobara/domain"
+
 module Foobara
   class Error < StandardError
     foobara_autoregister_subclasses(default_namespace: Foobara::GlobalDomain)
@@ -188,15 +190,37 @@ module Foobara
       end
     end
 
-    foobara_delegate :runtime_path,
-                     :runtime_path=,
-                     :category,
-                     :category=,
-                     :path,
-                     :path=,
-                     :symbol,
-                     :symbol=,
-                     to: :error_key
+    def runtime_path
+      error_key.runtime_path
+    end
+
+    def runtime_path=(runtime_path)
+      error_key.runtime_path = runtime_path
+    end
+
+    def category
+      error_key.category
+    end
+
+    def category=(category)
+      error_key.category = category
+    end
+
+    def path
+      error_key.path
+    end
+
+    def path=(path)
+      error_key.path = path
+    end
+
+    def symbol
+      error_key.symbol
+    end
+
+    def symbol=(symbol)
+      error_key.symbol = symbol
+    end
 
     # TODO: seems like we should not allow the symbol to vary within instances of a class
     # TODO: any items serializable in self.class.to_h should not be overrideable like this...

data/projects/{common → typesystem/projects/common}/src/error_key.rb

@@ -2,7 +2,7 @@ module Foobara
   # TODO: paths have use outside of errors. Make this more general.
   class ErrorKey
     # TODO: use this wherever it makes sense
-    EMPTY_PATH = [].freeze
+    EMPTY_PATH = EMPTY_ARRAY
 
     class << self
       def to_s_type(key)

data/projects/{common → typesystem/projects/common}/src/outcome.rb

@@ -55,14 +55,18 @@ module Foobara
       end
     end
 
-    foobara_delegate :has_error, :add_errors, to: :error_collection
+    def has_error
+      # :nocov:
+      error_collection.has_error
+      # :nocov:
+    end
 
-    def has_errors?
-      error_collection.has_errors?
+    def add_errors(*errors)
+      error_collection.add_errors(*errors)
     end
 
-    def add_errors(...)
-      error_collection.add_errors(...)
+    def has_errors?
+      error_collection.has_errors?
     end
 
     def errors

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

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

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

@@ -0,0 +1,6 @@
+require "foobara/project"
+
+module Foobara::Delegate; end
+
+# TODO: we should just kill this project
+Foobara.project("delegate", project_path: "#{__dir__}/../..")

data/projects/{delegate → typesystem/projects/delegate}/src/extensions/module.rb

@@ -1,5 +1,8 @@
 class Module
+  # :nocov:
   def foobara_delegate(*method_names, to:, allow_nil: false)
+    warn "[DEPRECATION] `foobara_delegate` is deprecated and will be removed in future versions"
+
     method_names.each do |method_name|
       define_method method_name do |*args, **opts, &block|
         target = to.is_a?(::Symbol) || to.is_a?(::String) ? send(to) : to
@@ -9,4 +12,5 @@ class Module
       end
     end
   end
+  # :nocov:
 end

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

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

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

@@ -20,14 +20,12 @@ module Foobara
         when Foobara::Scoped
           if object.is_a?(Module) && object.foobara_domain?
             object
+          elsif object == Namespace.global
+            GlobalDomain
+          elsif object.scoped_path_set? && object.scoped_path.empty?
+            object.foobara_lookup_domain!("")
           else
-            parent = object.scoped_namespace
-
-            if parent
-              to_domain(parent)
-            else
-              GlobalDomain
-            end
+            to_domain(object.scoped_namespace)
           end
         else
           # :nocov:
@@ -79,6 +77,21 @@ module Foobara
       def current
         to_domain(Namespace.current)
       end
+
+      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)
+            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
+          else
+            new_class.const_set(const_name, value)
+          end
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,255 @@
+module Foobara
+  module Domain
+    class NoSuchDomain < StandardError; end
+    class AlreadyRegisteredError < StandardError; end
+    class CannotSetTypeConstantError < StandardError; end
+
+    class << self
+      def global
+        GlobalDomain
+      end
+    end
+
+    module DomainModuleExtension
+      include Concern
+      include Manifestable
+
+      module ClassMethods
+        attr_writer :foobara_domain_name, :foobara_full_domain_name
+
+        def foobara_domain_map(*args, to: nil, strict: false, criteria: nil, should_raise: false, **opts)
+          case args.size
+          when 1
+            value = args.first
+          when 0
+            if opts.empty?
+              # :nocov:
+              raise ArgumentError, "Expected at least one argument"
+              # :nocov:
+            else
+              value = opts
+              opts = {}
+            end
+          else
+            # :nocov:
+            raise ArgumentError, "Expected 1 argument but got #{args.size}"
+            # :nocov:
+          end
+
+          invalid_keys = opts.keys - [:from]
+
+          if invalid_keys.any?
+            # :nocov:
+            raise ArgumentError, "Invalid options: #{invalid_keys.join(", ")}"
+            # :nocov:
+          end
+
+          from = if opts.key?(:from)
+                   opts[:from]
+                 else
+                   value
+                 end
+
+          mapper = lookup_matching_domain_mapper(from:, to:, criteria:, strict:)
+
+          if mapper
+            mapper.map!(value)
+          elsif should_raise
+            raise Foobara::DomainMapperLookups::NoDomainMapperFoundError.new(from, to, value:)
+          end
+        end
+
+        def foobara_domain_map!(*, **, &)
+          foobara_domain_map(*, should_raise: true, **, &)
+        end
+
+        def foobara_domain_name
+          # TODO: does this work properly with prefixes?
+          @foobara_domain_name || scoped_name
+        end
+
+        def foobara_full_domain_name
+          @foobara_full_domain_name || scoped_full_name
+        end
+
+        def foobara_full_domain_symbol
+          Util.underscore_sym(foobara_full_domain_name)
+        end
+
+        def foobara_organization_name
+          foobara_organization&.foobara_organization_name
+        end
+
+        def foobara_full_organization_name
+          foobara_organization&.foobara_full_organization_name
+        end
+
+        def foobara_organization
+          parent = foobara_parent_namespace
+
+          while parent
+            return parent if parent&.foobara_organization?
+
+            # TODO: we really should test this path
+            # :nocov:
+            parent = parent.foobara_parent_namespace
+            # :nocov:
+          end || GlobalOrganization
+        end
+
+        def foobara_domain?
+          true
+        end
+
+        # TODO: kill this off
+        def foobara_type_builder
+          @foobara_type_builder ||= begin
+            accesses = self == GlobalDomain ? [] : GlobalDomain.foobara_type_builder
+            TypeDeclarations::TypeBuilder.new(foobara_full_domain_name, accesses:)
+          end
+        end
+
+        def foobara_type_from_declaration(*args, **opts, &block)
+          if opts.empty? && block.nil? && args.size == 1 && args.first.is_a?(Types::Type)
+            return args.first
+          end
+
+          Foobara::Namespace.use self do
+            foobara_type_builder.type_for_declaration(*args, **opts, &block)
+          end
+        end
+
+        def foobara_type_from_strict_stringified_declaration(...)
+          Foobara::Namespace.use self do
+            foobara_type_builder.type_for_strict_stringified_declaration(...)
+          end
+        end
+
+        def foobara_type_from_strict_declaration(...)
+          Foobara::Namespace.use self do
+            foobara_type_builder.type_for_strict_declaration(...)
+          end
+        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
+                 else
+                   foobara_type_from_declaration(*type_declaration_bits, &block)
+                 end
+
+          new_scoped_path, new_type_symbol = if type_symbol.is_a?(::Array)
+                                               [type_symbol, type_symbol.join("::").to_sym]
+                                             else
+                                               type_symbol = type_symbol.to_s if type_symbol.is_a?(::Symbol)
+
+                                               [type_symbol.split("::"), type_symbol.to_sym]
+                                             end
+
+          if type.scoped_path_set? && type.registered? && foobara_registered?(type, mode: Namespace::LookupMode::DIRECT)
+            old_symbol = type.type_symbol
+            old_type = foobara_lookup_type(old_symbol, mode: Namespace::LookupMode::DIRECT)
+
+            if old_symbol != new_type_symbol
+              foobara_unregister(type)
+
+              type.scoped_path = new_scoped_path
+              type.type_symbol = new_type_symbol
+
+              foobara_register(type)
+              # :nocov:
+            elsif old_type != type
+              # TODO: delete this check if it's not really helping
+
+              raise "Didn't expect to find an old type"
+              # :nocov:
+            end
+          else
+            type.scoped_path = new_scoped_path
+            type.type_symbol = new_type_symbol
+
+            old_type = foobara_lookup_type(new_type_symbol, mode: Namespace::LookupMode::DIRECT)
+
+            if old_type && old_type != type
+              # TODO: delete this check if it's not really helping
+              # :nocov:
+              raise "Didn't expect to find an old type"
+              # :nocov:
+            end
+
+            if foobara_registered?(type, mode: Namespace::LookupMode::DIRECT)
+              # TODO: delete this check if it's not really helping
+              # :nocov:
+              raise "Already registered: #{type.inspect}"
+              # :nocov:
+            end
+
+            foobara_register(type)
+          end
+
+          type
+        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)
+        end
+
+        def foobara_depends_on(*domains)
+          if domains.empty?
+            return @foobara_depends_on ||= Set.new
+          end
+
+          if domains.length == 1
+            domains = Util.array(domains.first)
+          end
+
+          domains.each do |domain|
+            # It very likely could be a module extended with domain methods...
+            domain = Domain.to_domain(domain)
+            domain_name = domain.foobara_full_domain_name
+
+            if foobara_depends_on.include?(domain_name)
+              # :nocov:
+              raise AlreadyRegisteredDomainDependency, "Already registered #{domain_name} as a dependency of #{self}"
+              # :nocov:
+            end
+
+            foobara_depends_on_namespaces << domain
+            foobara_type_builder.accesses << domain.foobara_type_builder
+
+            lru_cache.reset!
+            foobara_depends_on << domain_name
+          end
+        end
+
+        def foobara_manifest
+          to_include = TypeDeclarations.foobara_manifest_context_to_include
+
+          depends_on = foobara_depends_on.map do |name|
+            domain = Domain.to_domain(name)
+            if to_include
+              to_include << domain
+            end
+            domain.foobara_manifest_reference
+          end.sort
+
+          types = foobara_all_type(mode: Namespace::LookupMode::DIRECT).map do |type|
+            if to_include
+              to_include << type
+            end
+            type.foobara_manifest_reference
+          end.sort
+
+          manifest = super.merge(types:)
+
+          unless depends_on.empty?
+            manifest[:depends_on] = depends_on
+          end
+
+          manifest
+        end
+      end
+    end
+  end
+end

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...