foobara 0.3.0 → 0.4.1

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

@@ -0,0 +1,335 @@
+RSpec.describe Foobara::Namespace do
+  describe "#register" do
+    let(:namespace_name) { "SomeNamespace" }
+    let(:namespace) { described_class.new(namespace_name, parent_namespace:) }
+    let(:scoped_object) { Object.new }
+    let(:scoped_name) { "scoped_name" }
+    let(:parent_namespace) { nil }
+
+    before do
+      scoped_object.extend(Foobara::Scoped)
+      expect(scoped_object).to_not be_scoped_path_set
+      scoped_object.scoped_name = scoped_name
+    end
+
+    it "registers the object and it can be found again" do
+      expect(scoped_object.scoped_short_path).to eq([scoped_name])
+      expect(scoped_object.scoped_full_path).to eq([scoped_name])
+      expect(scoped_object.scoped_absolute_name).to eq("::#{scoped_name}")
+      expect(scoped_object.scoped_full_name).to eq(scoped_name)
+
+      namespace.foobara_register(scoped_object)
+
+      expect(scoped_object.scoped_namespace).to be(namespace)
+
+      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
+
+    context "with prefixes" do
+      let(:scoped_name) { :"some::prefix::scoped_name" }
+
+      it "registers the object and it can be found again" do
+        namespace.foobara_register(scoped_object)
+
+        keys = [
+          "some::prefix::scoped_name",
+          "scoped_name",
+          ["some", "prefix", "scoped_name"],
+          ["scoped_name"],
+          "::some::prefix::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
+
+      context "with ambiguous prefixes" do
+        let(:scoped_name) { "some::prefix::scoped_name" }
+        let(:scoped_name2) { "some::prefix2::scoped_name" }
+
+        let(:scoped_object2) do
+          Object.new.tap do |object|
+            object.extend(Foobara::Scoped)
+            object.scoped_name = scoped_name2
+          end
+        end
+
+        it "registers the objects and they can be found again" do
+          namespace.foobara_register(scoped_object)
+          namespace.foobara_register(scoped_object2)
+
+          keys = [
+            "scoped_name",
+            ["scoped_name"]
+          ]
+
+          keys.each do |key|
+            expect {
+              namespace.foobara_lookup!(key)
+            }.to raise_error(Foobara::Namespace::AmbiguousLookupError)
+          end
+
+          keys = [
+            "some::prefix::scoped_name",
+            ["some", "prefix", "scoped_name"],
+            "::some::prefix::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
+
+          keys = [
+            "some::prefix2::scoped_name",
+            ["some", "prefix2", "scoped_name"],
+            "::some::prefix2::scoped_name"
+          ]
+
+          keys.each do |key|
+            expect(namespace.foobara_lookup!(key)).to be(scoped_object2)
+            expect(namespace.foobara_lookup(key)).to be(scoped_object2)
+          end
+        end
+      end
+
+      context "with parent namespaces" do
+        let(:grandparent_namespace) do
+          described_class.new(["GrandparentPrefix1", "GrandParentPrefix2", "GrandparentNamespace"])
+        end
+
+        let(:parent_namespace) do
+          described_class.new("ParentNamespace", parent_namespace: grandparent_namespace)
+        end
+
+        it "registers the object and it can be found again" do
+          expect(namespace.foobara_root_namespace).to be(grandparent_namespace)
+
+          namespace.foobara_register(scoped_object)
+
+          keys = [
+            "some::prefix::scoped_name",
+            "scoped_name",
+            "GrandparentPrefix1::GrandParentPrefix2::GrandparentNamespace::ParentNamespace::SomeNamespace::some::" \
+            "prefix::scoped_name",
+            ["some", "prefix", "scoped_name"],
+            ["scoped_name"],
+            ["GrandparentPrefix1", "GrandParentPrefix2", "GrandparentNamespace", "ParentNamespace", "SomeNamespace",
+             "some", "prefix", "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
+    end
+
+    context "with on_change callbacks" do
+      let(:listener) do
+        Object.new.tap do |o|
+          o.instance_eval do
+            def calls
+              @calls ||= 0
+            end
+
+            def changed
+              @calls ||= 0
+              @calls += 1
+            end
+          end
+        end
+      end
+
+      before do
+        described_class.on_change(listener, :changed)
+      end
+
+      it "calls the listener when a new type is registered" do
+        expect(listener.calls).to eq(0)
+
+        namespace.foobara_register(scoped_object)
+
+        expect(listener.calls).to eq(1)
+      end
+    end
+  end
+
+  describe "#lookup" do
+    context "when using instance of categories" do
+      let(:namespace) { described_class.new("SomeNamespace") }
+
+      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
+
+        it "has expected respond_to? results" do
+          expect(namespace).to respond_to(:foobara_lookup_class1)
+          expect(namespace).to respond_to(:foobara_lookup_class1!)
+          expect(namespace).to respond_to(:foobara_lookup_class2)
+          expect(namespace).to respond_to(:foobara_lookup_class2!)
+          expect(namespace).to_not respond_to(:foobara_lookup_class3)
+          expect(namespace).to_not respond_to(:foobara_lookup_class3!)
+        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
+
+          context "when looking up with non-matching lookup_class2 method" do
+            it "does not return the object" do
+              expect(namespace.foobara_lookup_class2(scoped_name)).to be_nil
+              expect {
+                namespace.foobara_lookup_class2!(scoped_name)
+              }.to raise_error(Foobara::Namespace::NotFoundError)
+            end
+          end
+
+          context "when all objects registered" do
+            before do
+              namespace.foobara_register(object2)
+              namespace.foobara_register(object3)
+            end
+
+            it "can fetch the proper items with different lookup_* methods" do
+              expect(namespace.foobara_lookup_class1(scoped_name)).to be(object1)
+              expect(namespace.foobara_lookup_class2(scoped_name)).to be(object2)
+            end
+
+            describe "#foobara_all" do
+              it "returns the proper items" do
+                expect(namespace.foobara_all).to eq(objects)
+              end
+
+              context "with a filter" do
+                it "returns the proper items" do
+                  expect(namespace.foobara_all_class1).to eq([object1])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context "when using subclass of categories" do
+      let(:namespace) { described_class.new("SomeNamespace") }
+
+      let(:base_class) do
+        Class.new do
+          extend Foobara::Scoped
+
+          class << self
+            def scoped_path
+              ["some_scoped_name"]
+            end
+          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(:class_a) { Class.new(class1) }
+      let(:class_b) { Class.new(class2) }
+      let(:class_c) { Class.new(class3) }
+
+      context "when there are two categories" do
+        before do
+          namespace.foobara_add_category_for_subclass_of(:class1, class1)
+          namespace.foobara_add_category_for_subclass_of(:class2, class2)
+        end
+
+        context "when an object is registered" do
+          before do
+            namespace.foobara_register(class_a)
+          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(class_a)
+              expect(namespace.foobara_lookup_class1!(scoped_name)).to be(class_a)
+              expect(namespace.foobara_lookup(scoped_name)).to be(class_a)
+              expect(namespace.foobara_lookup!(scoped_name)).to be(class_a)
+            end
+          end
+
+          context "when looking up with non-matching lookup_class2 method" do
+            it "does not return the object" do
+              expect(namespace.foobara_lookup_class2(scoped_name)).to be_nil
+              expect {
+                namespace.foobara_lookup_class2!(scoped_name)
+              }.to raise_error(Foobara::Namespace::NotFoundError)
+            end
+          end
+
+          context "when all objects registered" do
+            before do
+              namespace.foobara_register(class_b)
+              namespace.foobara_register(class_c)
+            end
+
+            it "can fetch the proper items with different lookup_* methods" do
+              expect(namespace.foobara_lookup_class1(scoped_name)).to be(class_a)
+              expect(namespace.foobara_lookup_class2(scoped_name)).to be(class_b)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+RSpec.describe Foobara::Namespace::PrefixlessRegistry 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
+
+  let(:user) { user_class.new("User") }
+
+  describe "#register" do
+    it "registers the user and can look it up" do
+      registry.register(user)
+      expect(registry.lookup(user.scoped_path)).to eq(user)
+    end
+
+    context "when scoped has a prefix" do
+      it "raises" do
+        expect {
+          registry.register(user_class.new("a::User"))
+        }.to raise_error(Foobara::Namespace::PrefixlessRegistry::RegisteringScopedWithPrefixError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+RSpec.describe Foobara::Namespace::UnambiguousRegistry 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
+
+  let(:user1) { user_class.new("a::User") }
+  let(:user2) { user_class.new("b::User") }
+
+  describe "#register" do
+    context "when registering ambiguous entries" do
+      it "raises" do
+        registry.register(user1)
+
+        expect {
+          registry.register(user2)
+        }.to raise_error(Foobara::Namespace::BaseRegistry::WouldMakeRegistryAmbiguousError)
+      end
+    end
+  end
+
+  describe "#unregister" do
+    context "when not registered" do
+      it "raises" do
+        expect {
+          registry.unregister(user1)
+        }.to raise_error(Foobara::Namespace::BaseRegistry::NotRegisteredError)
+      end
+    end
+
+    context "when registered" do
+      before do
+        registry.register(user1)
+      end
+
+      it "unregisters" do
+        expect {
+          registry.unregister(user1)
+        }.to change { registry.registered?(user1.scoped_path) }.from(true).to(false)
+      end
+    end
+  end
+end

data/projects/typesystem/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+ENV["FOOBARA_ENV"] = "test"
+
+require "bundler/setup"
+
+unless ENV["SKIP_PRY"] == "true" || ENV["CI"] == "true"
+  require "pry"
+  require "pry-byebug"
+end
+
+require "rspec/its"
+require "simplecov"
+
+SimpleCov.root "#{__dir__}/../../../"
+SimpleCov.command_name "typesystem"
+SimpleCov.coverage_dir "coverage/typesystem"
+
+SimpleCov.start do
+  add_filter "spec/support/"
+  # TODO: when we run rspec in the typesystem/ directory we sholud print this info out
+  # This avoids printing out info about coverage generated by HTTPFormatter
+  formatter Class.new { def format(_result) = nil }
+end
+
+# TODO: we should be able to remove these once all projects are separated
+require "foobara/delegate"
+require "foobara/state_machine"
+require "foobara/builtin_types"
+
+Foobara.install!
+
+RSpec.configure do |config|
+  config.filter_run_when_matching :focus
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.order = :defined
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # config.raise_errors_for_deprecations!
+end
+
+require "foobara/spec_helpers/all"
+Dir["#{__dir__}/support/**/*.rb"].each { |f| require f }

data/projects/typesystem/spec/state_machine/callbacks_spec.rb

@@ -0,0 +1,144 @@
+RSpec.describe Foobara::StateMachine::Callbacks do
+  subject { state_machine_class }
+
+  let(:state_machine_class) do
+    Foobara::StateMachine.for(transition_map)
+  end
+
+  let(:state_machine) { state_machine_class.new }
+
+  let(:transition_map) do
+    {
+      unexecuted: {
+        start: :running
+      },
+      running: {
+        fail: :failed,
+        succeed: :succeeded,
+        reset: :unexecuted
+      }
+    }
+  end
+
+  describe "dynamic transition callback helpers" do
+    # before after around error any
+    # from
+    # to
+    # from to
+    # tx from
+    # tx to
+    let(:calls) { [] }
+    let(:from) { :unexecuted }
+    let(:to) { :running }
+    let(:transition) { :start }
+
+    def set_callback(callback_name)
+      record_call = ->(**_opts) { calls << callback_name }
+
+      block = case callback_name
+              when /^around_/
+                ->(**_opts, &do_it) {
+                  record_call.call
+                  do_it.call
+                }
+              when /^error_/
+                ->(_error) { record_call.call }
+              else
+                record_call
+              end
+
+      state_machine.send(callback_name, &block)
+    end
+
+    it "calls them all" do
+      [:before, :around, :after, :error].each do |type|
+        [
+          "#{type}_any_transition",
+          "#{type}_transition_from_#{from}",
+          "#{type}_transition_to_#{to}",
+          "#{type}_transition_from_#{from}_to_#{to}",
+          "#{type}_#{transition}",
+          "#{type}_#{transition}_from_#{from}",
+          "#{type}_#{transition}_to_#{to}",
+          "#{type}_#{transition}_from_#{from}_to_#{to}"
+        ].each do |callback_name|
+          set_callback(callback_name)
+        end
+      end
+
+      state_machine.perform_transition!(transition)
+
+      # 8 for each type but error type won't be called here
+      expect(calls.size).to eq(24)
+
+      expect(calls).to contain_exactly(
+        "before_start_from_unexecuted_to_running",
+        "before_transition_from_unexecuted_to_running",
+        "before_start_from_unexecuted",
+        "before_transition_from_unexecuted",
+        "before_start_to_running",
+        "before_transition_to_running",
+        "before_start",
+        "before_any_transition",
+        "around_any_transition",
+        "around_start",
+        "around_transition_to_running",
+        "around_start_to_running",
+        "around_transition_from_unexecuted",
+        "around_start_from_unexecuted",
+        "around_transition_from_unexecuted_to_running",
+        "around_start_from_unexecuted_to_running",
+        "after_start_from_unexecuted_to_running",
+        "after_transition_from_unexecuted_to_running",
+        "after_start_from_unexecuted",
+        "after_transition_from_unexecuted",
+        "after_start_to_running",
+        "after_transition_to_running",
+        "after_start",
+        "after_any_transition"
+      )
+
+      state_machine.reset!
+
+      calls.clear
+
+      state_machine.around_any_transition do |&do_it|
+        do_it.call
+        raise "kaboom"
+      end
+
+      expect {
+        state_machine.start!
+      }.to raise_error("kaboom")
+
+      # 8 before, 8 around, and 8 error callbacks (we never make it to after because of the raise)
+      expect(calls.size).to eq(24)
+      expect(calls).to contain_exactly(
+        "before_start_from_unexecuted_to_running",
+        "before_transition_from_unexecuted_to_running",
+        "before_start_from_unexecuted",
+        "before_transition_from_unexecuted",
+        "before_start_to_running",
+        "before_transition_to_running",
+        "before_start",
+        "before_any_transition",
+        "around_any_transition",
+        "around_start",
+        "around_transition_to_running",
+        "around_start_to_running",
+        "around_transition_from_unexecuted",
+        "around_start_from_unexecuted",
+        "around_transition_from_unexecuted_to_running",
+        "around_start_from_unexecuted_to_running",
+        "error_start_from_unexecuted_to_running",
+        "error_transition_from_unexecuted_to_running",
+        "error_start_from_unexecuted",
+        "error_transition_from_unexecuted",
+        "error_start_to_running",
+        "error_transition_to_running",
+        "error_start",
+        "error_any_transition"
+      )
+    end
+  end
+end