foobara 0.5.10 → 0.6.2

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

@@ -1,254 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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