foobara 0.3.0 → 0.4.1

data/projects/typesystem/spec/namespace/ambiguous_registry_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe Foobara::Namespace::AmbiguousRegistry do
+  let(:registry) { described_class.new }
+
+  let(:user_class) do
+    Class.new do
+      include Foobara::Scoped
+
+      def initialize(full_name)
+        self.scoped_name = full_name
+      end
+    end
+  end
+
+  context "when there's some conflicting entries" do
+    let(:user1) { user_class.new("User") }
+    let(:user2) { user_class.new("a::User") }
+    let(:user3) { user_class.new("a::b::User") }
+    let(:user4) { user_class.new("b::User") }
+    let(:user5) { user_class.new("b::UniqueUser") }
+    let(:user6) { user_class.new("a::b::c::d::User") }
+    let(:user7) { user_class.new("z::a::User") }
+    let(:user8) { user_class.new("z::b::User") }
+
+    let(:users) { [user1, user2, user3, user4, user5, user6, user7, user8] }
+
+    before do
+      users.each do |user|
+        registry.register(user)
+      end
+    end
+
+    context "when looking up by full-paths" do
+      it "returns the expected users" do
+        users.each do |user|
+          expect(registry.lookup(user.scoped_path)).to eq(user)
+        end
+      end
+    end
+
+    context "when looking up by unambiguous key" do
+      it "returns the expected users" do
+        expect(registry.lookup(["d", "User"])).to eq(user6)
+      end
+    end
+
+    context "when looking up by very ambiguous key" do
+      it "raises" do
+        expect {
+          registry.lookup(["z", "User"])
+        }.to raise_error(Foobara::Namespace::AmbiguousLookupError)
+      end
+    end
+
+    context "when looking up by kind-of ambiguous key" do
+      it "returns the best guess" do
+        expect(registry.lookup(["a", "User"])).to eq(user2)
+      end
+    end
+
+    describe "#unregister" do
+      it "unregisters the element" do
+        expect(registry.lookup(["z", "a", "User"])).to eq(user7)
+
+        registry.unregister(user7)
+
+        expect(registry.lookup(["z", "a", "User"])).to be_nil
+      end
+    end
+  end
+end

data/projects/typesystem/spec/namespace/foobara_simulation_spec.rb

@@ -0,0 +1,254 @@
+RSpec.describe Foobara::Namespace do
+  after do
+    Object.send(:remove_const, :FoobaraSimulation)
+  end
+
+  before do
+    # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+    module FoobaraSimulation
+      module Foobara
+        foobara_root_namespace!(ignore_modules: FoobaraSimulation)
+        foobara_depends_on_namespaces << ::Foobara::Namespace.global
+      end
+
+      # TODO: support concept of abstract classes...
+      class Org
+        foobara_subclasses_are_namespaces!(default_parent: Foobara, autoregister: true)
+      end
+
+      class Domain
+        foobara_subclasses_are_namespaces!(default_parent: Foobara, autoregister: true)
+      end
+
+      class Command
+        foobara_subclasses_are_namespaces!(default_parent: Foobara, autoregister: true)
+      end
+
+      class Type
+        foobara_instances_are_namespaces!
+
+        def add_processor(processor)
+          foobara_register(processor)
+        end
+
+        def initialize(scoped_path)
+          self.scoped_path = ::Foobara::Util.array(scoped_path)
+          super
+        end
+      end
+
+      class Processor
+        !foobara_subclasses_are_namespaces!(default_parent: Foobara)
+      end
+
+      class Error
+        foobara_autoregister_subclasses(default_namespace: Foobara)
+      end
+
+      module Foobara
+        foobara_add_category_for_subclass_of(:org, Org)
+        foobara_add_category_for_subclass_of(:domain, Domain)
+        foobara_add_category_for_subclass_of(:command, Command)
+        foobara_add_category_for_instance_of(:type, Type)
+        foobara_add_category_for_subclass_of(:processor, Processor)
+        foobara_add_category_for_subclass_of(:error, Error)
+      end
+
+      class GlobalError < Error
+      end
+
+      Integer = Type.new(:integer)
+      Foobara.foobara_register(Integer)
+
+      class Max < Processor
+        class TooBig < Error
+        end
+      end
+
+      Integer.add_processor(Max)
+
+      class OrgA < Org
+        class DomainA < Domain
+          CustomType = Type.new(:custom_type)
+          foobara_register(CustomType)
+
+          class CommandA < Command
+          end
+
+          class CommandB < Command
+          end
+        end
+
+        class DomainB < Domain
+          CustomType = Type.new(:custom_type)
+          foobara_register(CustomType)
+
+          class CommandA < Command
+            class SomeError < Error
+            end
+          end
+
+          class CommandB < Command
+          end
+
+          module Foo
+            module Bar
+              class CommandA < Command
+              end
+            end
+          end
+        end
+      end
+
+      class OrgB < Org
+        class DomainA < Domain
+          class CommandA < Command
+          end
+
+          class CommandB < Command
+          end
+        end
+
+        class DomainB < Domain
+          class CommandA < Command
+          end
+
+          class CommandB < Command
+          end
+
+          module Foo
+            module Bar
+              class CommandA < Command
+              end
+            end
+          end
+        end
+      end
+
+      class GlobalDomain < Domain
+        class CommandA < Command
+        end
+
+        class CommandB < Command
+        end
+
+        module Foo
+          module Bar
+            class CommandA < Command
+            end
+          end
+        end
+      end
+    end
+    # rubocop:enable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+  end
+
+  describe "#lookup_*" do
+    it "finds the expected objects given certain paths" do
+      attributes = FoobaraSimulation::OrgA::DomainA.foobara_lookup("::attributes")
+      expect(attributes).to be(Foobara::BuiltinTypes[:attributes])
+
+      expect(FoobaraSimulation::OrgA.foobara_parent_namespace).to eq(FoobaraSimulation::Foobara)
+      expect(FoobaraSimulation::OrgA.scoped_path).to eq(["OrgA"])
+      expect(FoobaraSimulation::OrgA.scoped_full_path).to eq(["OrgA"])
+      expect(FoobaraSimulation::Foobara.foobara_lookup_org("OrgA")).to eq(FoobaraSimulation::OrgA)
+      expect(FoobaraSimulation::Foobara.foobara_lookup_org("::OrgA")).to eq(FoobaraSimulation::OrgA)
+
+      expect(FoobaraSimulation::OrgA::DomainA.foobara_parent_namespace).to eq(FoobaraSimulation::OrgA)
+      expect(FoobaraSimulation::OrgA::DomainA.scoped_path).to eq(["DomainA"])
+      expect(FoobaraSimulation::OrgA::DomainA.scoped_full_path).to eq(["OrgA", "DomainA"])
+      expect(FoobaraSimulation::OrgA::DomainA.scoped_full_name).to eq("OrgA::DomainA")
+      expect(FoobaraSimulation::OrgA::DomainA.scoped_absolute_name).to eq("::OrgA::DomainA")
+      expect(
+        FoobaraSimulation::Foobara.foobara_lookup_domain("OrgA::DomainA")
+      ).to eq(FoobaraSimulation::OrgA::DomainA)
+      expect(
+        FoobaraSimulation::Foobara.foobara_lookup_domain("::OrgA::DomainA")
+      ).to eq(FoobaraSimulation::OrgA::DomainA)
+
+      expect(FoobaraSimulation::OrgA::DomainA.foobara_lookup_domain(:DomainA)).to eq(FoobaraSimulation::OrgA::DomainA)
+      expect(FoobaraSimulation::OrgA::DomainA.foobara_lookup_domain("::DomainA")).to be_nil
+
+      expect(
+        FoobaraSimulation::OrgA::DomainA::CommandA.foobara_parent_namespace
+      ).to eq(FoobaraSimulation::OrgA::DomainA)
+      expect(FoobaraSimulation::OrgA::DomainA::CommandA.scoped_path).to eq(["CommandA"])
+      expect(FoobaraSimulation::OrgA::DomainA::CommandA.scoped_full_path).to eq(["OrgA", "DomainA", "CommandA"])
+      expect(FoobaraSimulation::OrgA::DomainA::CommandA.scoped_full_name).to eq("OrgA::DomainA::CommandA")
+      expect(FoobaraSimulation::OrgA::DomainA::CommandA.scoped_absolute_name).to eq("::OrgA::DomainA::CommandA")
+      expect(
+        FoobaraSimulation::Foobara.foobara_lookup_command("OrgA::DomainA::CommandA")
+      ).to eq(FoobaraSimulation::OrgA::DomainA::CommandA)
+      expect(
+        FoobaraSimulation::Foobara.foobara_lookup_command("::OrgA::DomainA::CommandA")
+      ).to eq(FoobaraSimulation::OrgA::DomainA::CommandA)
+
+      expect(FoobaraSimulation::GlobalError.scoped_namespace).to eq(FoobaraSimulation::Foobara)
+      expect(FoobaraSimulation::GlobalError.scoped_path).to eq(["GlobalError"])
+      expect(FoobaraSimulation::GlobalError.scoped_full_path).to eq(["GlobalError"])
+      expect(
+        FoobaraSimulation::Foobara.foobara_lookup_error("GlobalError")
+      ).to eq(FoobaraSimulation::GlobalError)
+      expect(
+        FoobaraSimulation::Foobara.foobara_lookup_error("::GlobalError")
+      ).to eq(FoobaraSimulation::GlobalError)
+
+      expect(
+        FoobaraSimulation::OrgA::DomainB::CommandA::SomeError.scoped_namespace
+      ).to eq(FoobaraSimulation::OrgA::DomainB::CommandA)
+
+      expect(FoobaraSimulation::Integer.foobara_parent_namespace).to eq(FoobaraSimulation::Foobara)
+      expect(FoobaraSimulation::Foobara.foobara_lookup_type("integer")).to eq(FoobaraSimulation::Integer)
+      expect(FoobaraSimulation::Foobara.foobara_lookup_type("::integer")).to eq(FoobaraSimulation::Integer)
+
+      expect(FoobaraSimulation::Integer.foobara_lookup_processor("Max")).to eq(FoobaraSimulation::Max)
+      expect(FoobaraSimulation::Integer.foobara_lookup_processor("Max")).to eq(FoobaraSimulation::Max)
+      expect(FoobaraSimulation::Foobara.foobara_lookup_processor("integer::Max")).to eq(FoobaraSimulation::Max)
+
+      expect(FoobaraSimulation::Max.foobara_lookup_error("TooBig")).to eq(FoobaraSimulation::Max::TooBig)
+      expect(
+        FoobaraSimulation::Foobara.foobara_lookup_error("integer::Max::TooBig")
+      ).to eq(FoobaraSimulation::Max::TooBig)
+
+      expect(FoobaraSimulation::Foobara.foobara_all(
+               mode: Foobara::Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+             )).to contain_exactly(
+               FoobaraSimulation::OrgA,
+               FoobaraSimulation::OrgA::DomainA,
+               FoobaraSimulation::OrgA::DomainA::CommandA,
+               FoobaraSimulation::OrgA::DomainA::CommandB,
+               FoobaraSimulation::OrgA::DomainA::CustomType,
+               FoobaraSimulation::OrgA::DomainB,
+               FoobaraSimulation::OrgA::DomainB::CommandA,
+               FoobaraSimulation::OrgA::DomainB::CommandA::SomeError,
+               FoobaraSimulation::OrgA::DomainB::CommandB,
+               FoobaraSimulation::OrgA::DomainB::Foo::Bar::CommandA,
+               FoobaraSimulation::OrgA::DomainB::CustomType,
+               FoobaraSimulation::OrgB,
+               FoobaraSimulation::OrgB::DomainA,
+               FoobaraSimulation::OrgB::DomainA::CommandA,
+               FoobaraSimulation::OrgB::DomainA::CommandB,
+               FoobaraSimulation::OrgB::DomainB,
+               FoobaraSimulation::OrgB::DomainB::CommandA,
+               FoobaraSimulation::OrgB::DomainB::CommandB,
+               FoobaraSimulation::OrgB::DomainB::Foo::Bar::CommandA,
+               FoobaraSimulation::GlobalDomain,
+               FoobaraSimulation::GlobalDomain::CommandA,
+               FoobaraSimulation::GlobalDomain::CommandB,
+               FoobaraSimulation::GlobalDomain::Foo::Bar::CommandA,
+               FoobaraSimulation::GlobalError,
+               FoobaraSimulation::Integer,
+               FoobaraSimulation::Max,
+               FoobaraSimulation::Max::TooBig
+             )
+    end
+
+    context "with relaxed mode" do
+      it "can find scoped object without prefixes" do
+        expect(
+          FoobaraSimulation::Foobara.foobara_lookup("TooBig", mode: Foobara::Namespace::LookupMode::RELAXED)
+        ).to eq(FoobaraSimulation::Max::TooBig)
+      end
+    end
+  end
+end

data/projects/typesystem/spec/namespace/is_namespace_spec.rb

@@ -0,0 +1,103 @@
+RSpec.describe Foobara::Namespace::IsNamespace do
+  let(:namespace) do
+    Object.new.tap do |o|
+      class << o
+        def scoped_path
+          ["SomeNamespace"]
+        end
+      end
+
+      o.extend described_class
+    end
+  end
+
+  describe "#register" do
+    let(:scoped_object) { Object.new }
+    let(:scoped_name) { "scoped_name" }
+    let(:parent_namespace) { nil }
+
+    before do
+      scoped_object.extend(Foobara::Scoped)
+      scoped_object.scoped_name = scoped_name
+    end
+
+    it "registers the object and it can be found again" do
+      expect(namespace.scoped_path).to eq(["SomeNamespace"])
+      expect(namespace.scoped_name).to eq("SomeNamespace")
+      expect(namespace.scoped_full_name).to eq("SomeNamespace")
+      expect(namespace.scoped_absolute_name).to eq("::SomeNamespace")
+
+      namespace.foobara_register(scoped_object)
+      expect(scoped_object.scoped_namespace).to be(namespace)
+
+      expect(scoped_object.scoped_short_path).to eq([scoped_name])
+      expect(scoped_object.scoped_full_path).to eq(["SomeNamespace", scoped_name])
+      expect(scoped_object.scoped_full_name).to eq("SomeNamespace::#{scoped_name}")
+      expect(scoped_object.scoped_absolute_name).to eq("::SomeNamespace::#{scoped_name}")
+
+      keys = [
+        "scoped_name",
+        ["scoped_name"]
+      ]
+
+      keys.each do |key|
+        expect(namespace.foobara_lookup(key)).to be(scoped_object)
+        expect(namespace.foobara_lookup!(key)).to be(scoped_object)
+      end
+    end
+  end
+
+  describe "#lookup" do
+    context "when using instance of categories" do
+      let(:base_class) do
+        Class.new do
+          include Foobara::Scoped
+
+          attr_accessor :name
+
+          def initialize(name)
+            self.name = name
+          end
+
+          def scoped_path
+            ["some_scoped_name"]
+          end
+        end
+      end
+
+      let(:scoped_name) { "some_scoped_name" }
+
+      let(:class1) { Class.new(base_class) }
+      let(:class2) { Class.new(base_class) }
+      let(:class3) { Class.new(base_class) }
+
+      let(:object1) { class1.new("object1") }
+      let(:object2) { class2.new("object2") }
+      let(:object3) { class3.new("object3") }
+
+      let(:objects) { [object1, object2, object3] }
+
+      context "when there are two categories" do
+        before do
+          namespace.foobara_add_category_for_instance_of(:class1, class1)
+          namespace.foobara_add_category_for_instance_of(:class2, class2)
+        end
+
+        context "when an object is registered" do
+          before do
+            namespace.foobara_register(object1)
+          end
+
+          context "when looking up with matching lookup_class1 method and lookup method" do
+            it "returns the object" do
+              expect(namespace.foobara_lookup_class1(scoped_name)).to be(object1)
+              expect(namespace.foobara_lookup_class1!(scoped_name)).to be(object1)
+              expect(namespace.foobara_lookup(scoped_name)).to be(object1)
+              expect(namespace.foobara_lookup!(scoped_name)).to be(object1)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/typesystem/spec/namespace/namespace_helpers_spec.rb

@@ -0,0 +1,67 @@
+RSpec.describe Foobara::Namespace::NamespaceHelpers do
+  describe ".foobara_instances_are_namespaces!" do
+    let(:instance) { klass.new(name) }
+
+    let(:default_parent) { Foobara::Namespace.new("ParentNamespace") }
+    let(:klass) do
+      stub_class("SomeClass") do
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+          super
+        end
+
+        def scoped_path
+          [name]
+        end
+      end
+    end
+    let(:autoregister) { true }
+    let(:name) { "some_name" }
+
+    before do
+      klass.foobara_instances_are_namespaces!(default_parent:, autoregister:)
+    end
+
+    it "sets up the instance as expected" do
+      expect(instance).to be_a(Foobara::Namespace::IsNamespace)
+      expect(instance.foobara_parent_namespace).to eq(default_parent)
+    end
+
+    context "when inherited" do
+      let(:subclass) { stub_class "SomeSubclass", klass }
+      let(:instance) { subclass.new(name) }
+
+      it "sets up the instance as expected" do
+        expect(instance).to be_a(subclass)
+        expect(instance).to be_a(Foobara::Namespace::IsNamespace)
+        expect(instance.foobara_parent_namespace).to eq(default_parent)
+      end
+    end
+  end
+
+  describe ".update_children_with_new_parent" do
+    let(:parent_module) do
+      stub_module("ParentModule")
+    end
+    let(:child_module) do
+      parent_module
+      stub_module("ParentModule::ChildModule") do
+        extend Foobara::Scoped
+
+        foobara_autoset_scoped_path!
+        Foobara::GlobalDomain.foobara_register(self)
+      end
+    end
+
+    context "when retroactively making parent module a namespace" do
+      it "updates the scoped_path" do
+        expect {
+          parent_module.foobara_namespace!
+          parent_module.foobara_autoset_scoped_path!
+        }.to change(child_module, :scoped_path).from(["ParentModule", "ChildModule"]).to(["ChildModule"])
+      end
+    end
+  end
+end