foobara 0.0.1

data/projects/namespace/src/namespace_helpers.rb

@@ -0,0 +1,273 @@
+require_relative "is_namespace"
+
+module Foobara
+  class Namespace
+    module NamespaceHelpers
+      module ScopedDefaultNamespace
+        include Concern
+
+        inherited_overridable_class_attr_accessor :scoped_default_namespace
+      end
+
+      module SubclassesAreNamespaces
+        include Concern
+
+        module ClassMethods
+          def inherited(subclass)
+            super
+
+            subclass.extend ::Foobara::Scoped
+
+            NamespaceHelpers.foobara_autoset_namespace(subclass, default_namespace: scoped_default_namespace)
+            NamespaceHelpers.foobara_autoset_scoped_path(subclass)
+
+            subclass.extend ::Foobara::Namespace::IsNamespace
+          end
+        end
+      end
+
+      module AutoRegisterSubclasses
+        include Concern
+
+        module ClassMethods
+          def inherited(subclass)
+            super
+
+            subclass.extend ::Foobara::Scoped
+
+            NamespaceHelpers.foobara_autoset_namespace(subclass, default_namespace: scoped_default_namespace)
+            NamespaceHelpers.foobara_autoset_scoped_path(subclass)
+
+            if subclass.scoped_namespace
+              if subclass.is_a?(Foobara::Namespace::IsNamespace)
+                subclass.foobara_parent_namespace = subclass.scoped_namespace
+              end
+
+              subclass.scoped_namespace.foobara_register(subclass)
+            end
+          end
+        end
+      end
+
+      module AutoRegisterInstances
+        include Concern
+
+        def initialize(*, **, &)
+          if Foobara::Util.super_method_takes_parameters?(self, AutoRegisterInstances, __method__)
+            super
+          else
+            # :nocov:
+            super()
+            # :nocov:
+          end
+
+          ns = scoped_namespace || self.class.scoped_default_namespace
+          ns&.foobara_register(self)
+        end
+      end
+
+      module InstancesAreNamespaces
+        include Concern
+
+        include ::Foobara::Namespace::IsNamespace
+
+        def initialize(*, **, &)
+          if Foobara::Util.super_method_takes_parameters?(self, InstancesAreNamespaces, __method__)
+            # :nocov:
+            super
+            # :nocov:
+          else
+            super()
+          end
+
+          parent_namespace = scoped_namespace || self.class.scoped_default_namespace
+          NamespaceHelpers.initialize_foobara_namespace(self, parent_namespace:)
+        end
+      end
+
+      class << self
+        def initialize_foobara_namespace(namespace, scoped_name_or_path = nil, parent_namespace: nil)
+          unless namespace.scoped_path_set?
+            scoped_name_or_path = scoped_name_or_path.to_s if scoped_name_or_path.is_a?(::Symbol)
+
+            if scoped_name_or_path.is_a?(::String)
+              namespace.scoped_name = scoped_name_or_path
+            elsif scoped_name_or_path.is_a?(::Array)
+              namespace.scoped_path = scoped_name_or_path
+            end
+          end
+
+          if namespace.scoped_path_set? && parent_namespace
+            namespace.foobara_parent_namespace = parent_namespace
+          end
+        end
+
+        def foobara_namespace!(object, scoped_path: nil, ignore_modules: nil)
+          object.extend ::Foobara::Scoped
+
+          if ignore_modules
+            object.scoped_ignore_modules = ignore_modules
+          end
+          object.scoped_path = scoped_path if scoped_path
+
+          object.extend ::Foobara::Namespace::IsNamespace
+
+          if object.scoped_path_set?
+            Namespace::NamespaceHelpers.update_children_with_new_parent(object)
+          end
+        end
+
+        def foobara_subclasses_are_namespaces!(klass, default_parent: nil, autoregister: nil)
+          klass.include ScopedDefaultNamespace unless klass < ScopedDefaultNamespace
+          klass.scoped_default_namespace = default_parent if default_parent
+
+          klass.include SubclassesAreNamespaces unless klass < SubclassesAreNamespaces
+
+          if autoregister
+            foobara_autoregister_subclasses(klass)
+          end
+        end
+
+        def foobara_instances_are_namespaces!(klass, default_parent: nil, autoregister: nil)
+          klass.include ScopedDefaultNamespace unless klass < ScopedDefaultNamespace
+          klass.scoped_default_namespace = default_parent if default_parent
+          klass.include InstancesAreNamespaces unless klass < InstancesAreNamespaces
+
+          if autoregister
+            klass.include AutoRegisterInstances
+          end
+        end
+
+        def foobara_autoregister_subclasses(klass, default_namespace: nil)
+          klass.include ScopedDefaultNamespace unless klass < ScopedDefaultNamespace
+          klass.scoped_default_namespace = default_namespace if default_namespace
+          klass.include AutoRegisterSubclasses unless klass < AutoRegisterSubclasses
+        end
+
+        def foobara_autoset_namespace(mod, default_namespace: nil)
+          return if mod.scoped_namespace
+
+          parent_mod = Util.module_for(mod)
+
+          while parent_mod
+            if parent_mod.is_a?(Foobara::Namespace::IsNamespace)
+              mod.scoped_namespace = parent_mod
+              return
+            else
+              parent_mod = Util.module_for(parent_mod)
+            end
+          end
+
+          mod.scoped_namespace = default_namespace if default_namespace
+        end
+
+        def foobara_autoset_scoped_path(mod, make_top_level: false)
+          return if mod.scoped_path_set?
+
+          scoped_path = mod.name.split("::")
+
+          adjusted_scoped_path = []
+
+          next_mod = Object
+
+          while next_mod
+            path_part = scoped_path.shift
+
+            break unless path_part
+
+            next_mod = Util.constant_value(next_mod, path_part)
+
+            if next_mod.is_a?(IsNamespace) && next_mod != mod && !make_top_level
+              adjusted_scoped_path = []
+              next
+            end
+
+            adjusted_scoped_path << path_part unless mod.scoped_namespace&.scoped_ignore_module?(next_mod)
+          end
+
+          mod.scoped_path_autoset = true
+          mod.scoped_path = adjusted_scoped_path
+
+          if mod.is_a?(IsNamespace)
+            update_children_with_new_parent(mod)
+          end
+        end
+
+        def update_children_with_new_parent(mod)
+          if mod.scoped_full_path.empty?
+            # hard to really know what we're trying to do here. Just bail out.
+            return
+          end
+
+          # how to do this?
+          # I guess we could just iterate over all objects and patch up any with matching prefixes?
+          # is this expensive to have to look at all of them or no? I guess at least it's a one-time thing.
+          # TODO: somehow look things up by prefixes since we know mod's path
+          Foobara.foobara_root_namespace.foobara_each do |scoped|
+            parent = scoped.scoped_namespace
+            next if parent == mod
+
+            if parent && !parent.scoped_full_path.empty?
+              next if _start_with?(parent.scoped_full_path, mod.scoped_full_path)
+            end
+
+            if _start_with?(scoped.scoped_full_path, mod.scoped_full_path)
+              scoped.scoped_path = scoped.scoped_full_path[mod.scoped_full_path.size..]
+
+              if parent
+                parent.foobara_unregister(scoped)
+
+                mod.foobara_register(scoped)
+
+                if scoped.is_a?(Namespace::IsNamespace)
+                  scoped.foobara_parent_namespace = mod
+                else
+                  scoped.scoped_namespace = mod
+                end
+              end
+            end
+          end
+        end
+
+        # TODO: move to util
+        def _start_with?(large_array, small_array)
+          return false unless large_array.size > small_array.size
+
+          small_array.each.with_index do |item, index|
+            return false unless large_array[index] == item
+          end
+
+          true
+        end
+      end
+
+      def foobara_namespace!(scoped_path: nil, ignore_modules: nil)
+        NamespaceHelpers.foobara_namespace!(self, scoped_path:, ignore_modules:)
+      end
+
+      def foobara_subclasses_are_namespaces!(default_parent: nil, autoregister: false)
+        NamespaceHelpers.foobara_subclasses_are_namespaces!(self, default_parent:, autoregister:)
+      end
+
+      def foobara_instances_are_namespaces!(default_parent: nil, autoregister: false)
+        NamespaceHelpers.foobara_instances_are_namespaces!(self, default_parent:, autoregister:)
+      end
+
+      def foobara_autoregister_subclasses(default_namespace: nil)
+        NamespaceHelpers.foobara_autoregister_subclasses(self, default_namespace:)
+      end
+
+      def foobara_root_namespace!(ignore_modules: nil)
+        foobara_namespace!(scoped_path: [], ignore_modules:)
+      end
+
+      def foobara_autoset_namespace!(default_namespace: nil)
+        NamespaceHelpers.foobara_autoset_namespace(self, default_namespace:)
+      end
+
+      def foobara_autoset_scoped_path!(make_top_level: false)
+        NamespaceHelpers.foobara_autoset_scoped_path(self, make_top_level:)
+      end
+    end
+  end
+end

data/projects/namespace/src/prefixless_registry.rb

@@ -0,0 +1,54 @@
+require_relative "base_registry"
+
+module Foobara
+  class Namespace
+    class PrefixlessRegistry < BaseRegistry
+      class RegisteringScopedWithPrefixError < StandardError; end
+
+      def registry
+        @registry ||= {}
+      end
+
+      def register(scoped)
+        key = to_key(scoped)
+
+        if registry.key?(key)
+          raise WouldMakeRegistryAmbiguousError, "#{key} is already registered"
+        end
+
+        registry[key] = scoped
+      end
+
+      def unregister(scoped)
+        key = to_key(scoped)
+
+        unless registry.key?(key)
+          # :nocov:
+          raise NotRegisteredError, "#{key} is not registered"
+          # :nocov:
+        end
+
+        registry.delete(key)
+      end
+
+      def lookup(path, filter = nil)
+        if path.size == 1
+          apply_filter(registry[path.first], filter)
+        end
+      end
+
+      def each_scoped_without_filter(&)
+        registry.each_value(&)
+      end
+
+      def to_key(scoped)
+        if scoped.scoped_prefix
+          raise RegisteringScopedWithPrefixError,
+                "Cannot register scoped with a prefix: #{scoped.scoped_name.inspect}"
+        end
+
+        scoped.scoped_short_name
+      end
+    end
+  end
+end

data/projects/namespace/src/scoped.rb

@@ -0,0 +1,113 @@
+module Foobara
+  module Scoped
+    class NoScopedPathSetError < StandardError; end
+
+    attr_reader :scoped_namespace
+
+    def scoped_path
+      unless defined?(@scoped_path)
+        # :nocov:
+        raise NoScopedPathSetError, "No scoped path set. Explicitly set it to nil if that's what you want."
+        # :nocov:
+      end
+
+      @scoped_path
+    end
+
+    def scoped_namespace=(scoped_namespace)
+      scoped_clear_caches
+
+      @scoped_namespace = scoped_namespace
+    end
+
+    def scoped_clear_caches
+      [
+        "@scoped_absolute_name",
+        "@scoped_name",
+        "@scoped_prefix",
+        "@scoped_full_name",
+        "@scoped_full_path"
+      ].each do |variable|
+        remove_instance_variable(variable) if instance_variable_defined?(variable)
+      end
+    end
+
+    def scoped_name=(name)
+      name = name.to_s if name.is_a?(::Symbol)
+      self.scoped_path = name.split("::")
+    end
+
+    def scoped_path=(path)
+      scoped_clear_caches
+
+      @scoped_path = path.map(&:to_s)
+    end
+
+    def scoped_path_autoset=(bool)
+      @scoped_path_autoset = bool
+    end
+
+    def scoped_path_autoset?
+      @scoped_path_autoset
+    end
+
+    def scoped_short_name
+      @scoped_short_name ||= scoped_path.last
+    end
+
+    def scoped_short_path
+      @scoped_short_path ||= [scoped_short_name]
+    end
+
+    def scoped_name
+      return @scoped_name if defined?(@scoped_name)
+
+      @scoped_name = unless scoped_path.empty?
+                       scoped_path.join("::")
+                     end
+    end
+
+    def scoped_full_path
+      @scoped_full_path ||= [*scoped_namespace&.scoped_full_path, *scoped_path]
+    end
+
+    def scoped_full_name
+      @scoped_full_name ||= scoped_full_path.join("::")
+    end
+
+    attr_writer :foobara_manifest_reference
+
+    def foobara_manifest_reference
+      @foobara_manifest_reference ||= scoped_full_name
+    end
+
+    def scoped_absolute_name
+      @scoped_absolute_name ||= "::#{scoped_full_name}"
+    end
+
+    def scoped_prefix
+      return @scoped_prefix if defined?(@scoped_prefix)
+
+      @scoped_prefix = unless scoped_path.size == 1
+                         scoped_path[0..-2]
+                       end
+    end
+
+    def scoped_path_set?
+      defined?(@scoped_path)
+    end
+
+    def scoped_ignore_module?(mod)
+      @scoped_ignore_modules&.include?(mod) || scoped_namespace&.scoped_ignore_module?(mod)
+    end
+
+    def scoped_ignore_modules=(modules)
+      mods = @scoped_ignore_modules || []
+      @scoped_ignore_modules = [*mods, *modules]
+    end
+
+    def scoped_category
+      @scoped_category ||= Namespace.global.foobara_category_symbol_for(self)
+    end
+  end
+end

data/projects/namespace/src/unambiguous_registry.rb

@@ -0,0 +1,65 @@
+require_relative "base_registry"
+
+module Foobara
+  class Namespace
+    class UnambiguousRegistry < BaseRegistry
+      def registry
+        @registry ||= {}
+      end
+
+      def register(scoped)
+        new_entries = {}
+
+        to_keys(scoped).each do |key|
+          if registry.key?(key)
+            raise WouldMakeRegistryAmbiguousError,
+                  "Ambiguous match for #{key.inspect}. Matches the following: #{registry[key].inspect}"
+          end
+
+          new_entries[key] = scoped
+        end
+
+        all << scoped
+
+        registry.merge!(new_entries)
+      end
+
+      def unregister(scoped)
+        all.delete(scoped)
+
+        to_keys(scoped).each do |key|
+          unless registry.key?(key)
+            raise NotRegisteredError, "Not registered: #{key.inspect}"
+          end
+
+          registry.delete(key)
+        end
+      end
+
+      def lookup(path, filter = nil)
+        apply_filter(registry[path], filter)
+      end
+
+      def each_scoped_without_filter(&)
+        # records can be unregistered in the block so dup first
+        all.dup.each(&)
+      end
+
+      private
+
+      # TODO: why don't we do this in UnambiguousRegistry??
+      def to_keys(scoped)
+        short_name = scoped.scoped_short_name
+        prefixes = scoped.scoped_prefix ? Util.power_set(scoped.scoped_prefix) : [[]]
+
+        prefixes.map do |prefix|
+          [*prefix, *short_name]
+        end
+      end
+
+      def all
+        @all ||= []
+      end
+    end
+  end
+end

data/projects/persistence/lib/foobara/persistence.rb

@@ -0,0 +1,22 @@
+module Foobara
+  module Persistence
+    class << self
+      def reset_all
+        @tables_for_entity_class_name = @bases = @default_crud_driver = @default_base = nil
+        EntityBase::Transaction::Concerns::EntityCallbackHandling.reset_all
+        EntityBase::Transaction.reset_all
+
+        Util.descendants(Foobara::Entity).each do |entity_class|
+          if entity_class.instance_variable_defined?(:@entity_base)
+            entity_class.remove_instance_variable(:@entity_base)
+          end
+        end
+      end
+
+      def install!
+        EntityBase::Transaction::Concerns::EntityCallbackHandling.install!
+        EntityBase::Transaction.install!
+      end
+    end
+  end
+end