foobara 0.5.10 → 0.6.2

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

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

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

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

@@ -1,52 +0,0 @@
-ENV["FOOBARA_ENV"] = "test"
-
-require "bundler/setup"
-
-if ENV["RUBY_DEBUG"] == "true"
-  require "debug"
-elsif ENV["SKIP_PRY"] != "true" && ENV["CI"] != "true"
-  require "pry"
-  require "pry-byebug" unless ENV["SKIP_BYEBUG"] == "true"
-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 should 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

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