foobara 0.5.10 → 0.6.2

data/projects/typesystem/spec/common/outcome_spec.rb

@@ -1,65 +0,0 @@
-RSpec.describe Foobara::Outcome do
-  around do |example|
-    Foobara::TypeDeclarations.with_validate_error_context_disabled do
-      example.run
-    end
-  end
-
-  describe ".raise!" do
-    subject { described_class.raise!(errors) }
-
-    context "when errors present" do
-      let(:errors) { [Foobara::Error.new(message: "message")] }
-
-      it { is_expected_to_raise(Foobara::Error) }
-    end
-
-    context "when no errors" do
-      let(:errors) { [] }
-
-      it { is_expected_to_not_raise }
-    end
-  end
-
-  describe "#raise!" do
-    subject { outcome.raise! }
-
-    context "when error present" do
-      let(:outcome) { described_class.error(Foobara::Error.new(message: "message")) }
-
-      it { is_expected_to_raise(Foobara::Error) }
-    end
-
-    context "when errors present" do
-      let(:outcome) do
-        described_class.errors(
-          Foobara::Error.new(symbol: :error1, message: "message1"),
-          Foobara::Error.new(symbol: :error2, message: "message2")
-        )
-      end
-
-      it { is_expected_to_raise(Foobara::Outcome::UnsuccessfulOutcomeError, /message1, message2/) }
-    end
-
-    context "when no errors" do
-      let(:outcome) { described_class.success(:foo) }
-
-      it { is_expected_to_not_raise }
-    end
-  end
-
-  describe "#errors_sentence" do
-    subject { outcome.errors_sentence }
-
-    let(:outcome) do
-      described_class.errors(
-        [
-          Foobara::Error.new(symbol: :error1, message: "message1"),
-          Foobara::Error.new(symbol: :error2, message: "message2")
-        ]
-      )
-    end
-
-    it { is_expected.to eq("message1, and message2") }
-  end
-end

data/projects/typesystem/spec/common/possible_error_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe Foobara::PossibleError do
-  describe "#initialize" do
-    context "with key and error_class" do
-      let(:possible_error) { described_class.new(error_class, key:) }
-
-      let(:key) { "data.foo.bar.baz" }
-      let(:error_class) { Foobara::RuntimeError }
-
-      it "creates an instance" do
-        expect(possible_error.key.path).to eq([:foo, :bar])
-        expect(possible_error.key.symbol).to eq(:baz)
-        expect(possible_error.key.category).to eq(:data)
-        expect(possible_error.error_class).to eq(Foobara::RuntimeError)
-      end
-    end
-  end
-end

data/projects/typesystem/spec/concerns/concern_spec.rb

@@ -1,122 +0,0 @@
-RSpec.describe "Foobara::Concern" do
-  context "when inheriting through another concern" do
-    let(:root_concern) do
-      stub_module "SomeModule" do
-        include Foobara::Concern
-
-        inherited_overridable_class_attr_accessor :some_delegated_value
-        inherited_overridable_class_attr_accessor :some_delegated_value2
-
-        on_include do
-          singleton_class.define_method :name_under do
-            Foobara::Util.underscore(name)
-          end
-        end
-      end
-
-      stub_module "SomeModule::ClassMethods" do
-        attr_accessor :some_non_delegated_value
-
-        def foo?
-          true
-        end
-      end
-
-      SomeModule
-    end
-
-    let(:sub_concern) do
-      r = root_concern
-
-      stub_module "SubConcern" do
-        include Foobara::Concern
-        include r
-      end
-    end
-
-    let(:klass) do
-      c = sub_concern
-
-      stub_class :SomeClass do
-        include c
-      end
-    end
-
-    it "passes class methods and effects of on_include through" do
-      expect(klass.singleton_class.ancestors.map(&:name)).to include("SubConcern::ClassMethods")
-      expect(klass.foo?).to be(true)
-      expect(klass.name_under).to eq("some_class")
-      klass.some_non_delegated_value = "hi!"
-      expect(klass.some_non_delegated_value).to eq("hi!")
-    end
-
-    context "when subclassing a class that included a concern with class methods" do
-      let(:subclass) do
-        stub_class :Subclass, klass
-      end
-
-      it "sets up the subclass and its instances correctly" do
-        expect(klass.singleton_class.ancestors.map(&:name)).to include("SubConcern::ClassMethods")
-        expect(klass.foo?).to be(true)
-        expect(klass.name_under).to eq("some_class")
-
-        klass.some_non_delegated_value = "foo"
-        expect(klass.some_non_delegated_value).to eq("foo")
-        expect(subclass.some_non_delegated_value).to be_nil
-        subclass.some_non_delegated_value = "bar"
-        expect(subclass.some_non_delegated_value).to eq("bar")
-        expect(klass.some_non_delegated_value).to eq("foo")
-      end
-    end
-
-    context "when there are delegated class methods" do
-      let(:class_a1) do
-        stub_class(:ClassA1).tap do |klass|
-          klass.include root_concern
-        end
-      end
-
-      let(:class_a2) do
-        stub_class(:ClassA2, ClassA1)
-      end
-
-      let(:class_a3) do
-        stub_class(:ClassA3, ClassA2)
-      end
-
-      let(:class_b1) do
-        stub_class(:ClassB1).tap do |klass|
-          klass.include root_concern
-        end
-      end
-
-      let(:all_classes) do
-        [class_a1, class_a2, class_a3, class_b1]
-      end
-
-      it "shares state in inheritance chains starting at its include." do
-        all_classes.each do |klass|
-          expect(klass.some_delegated_value).to be_nil
-        end
-
-        class_a1.some_delegated_value = "foo"
-        expect(class_a1.some_delegated_value).to eq("foo")
-        expect(class_a2.some_delegated_value).to eq("foo")
-        expect(class_a3.some_delegated_value).to eq("foo")
-        expect(class_b1.some_delegated_value).to be_nil
-
-        class_b1.some_delegated_value = "bar"
-        expect(class_a1.some_delegated_value).to eq("foo")
-        expect(class_a2.some_delegated_value).to eq("foo")
-        expect(class_a3.some_delegated_value).to eq("foo")
-        expect(class_b1.some_delegated_value).to eq("bar")
-
-        class_a3.some_delegated_value = "baz"
-        expect(class_a1.some_delegated_value).to eq("foo")
-        expect(class_a2.some_delegated_value).to eq("foo")
-        expect(class_a3.some_delegated_value).to eq("baz")
-        expect(class_b1.some_delegated_value).to eq("bar")
-      end
-    end
-  end
-end

data/projects/typesystem/spec/enumerated/accessors_spec.rb

@@ -1,182 +0,0 @@
-RSpec.describe Foobara::Enumerated::Accessors do
-  let(:enum_module) do
-    Module.new.tap do |m|
-      m.const_set(:FOO, :foo)
-      m.const_set(:BAR, :bar)
-      m.const_set(:BAZ, :baz)
-    end
-  end
-  let(:klass) do
-    Class.new do
-      include Foobara::Enumerated::Accessors
-
-      enumerated :some_enum, EnumModule
-    end
-  end
-  let(:object) { klass.new }
-
-  before do
-    stub_const("EnumModule", enum_module)
-  end
-
-  describe "setter/getter" do
-    subject {
-      object.some_enum = value
-      object.some_enum
-    }
-
-    context "when nil" do
-      let(:value) { nil }
-
-      it { is_expected.to be_nil }
-    end
-
-    context "when valid symbol" do
-      let(:value) { :bar }
-
-      it { is_expected.to be :bar }
-    end
-
-    context "when valid string" do
-      let(:value) { "bar" }
-
-      it { is_expected.to be :bar }
-    end
-
-    context "when invalid value" do
-      let(:value) { "not a member of the enum" }
-
-      it { is_expected_to_raise(Foobara::Enumerated::Accessors::ValueNotAllowed) }
-    end
-  end
-
-  describe ".enumerated_type_metadata" do
-    it "gives the reflection information" do
-      meta = klass.enumerated_type_metadata[:some_enum]
-
-      expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
-      expect(meta[:original_values_source]).to be(EnumModule)
-      expect(meta[:values_source]).to be(EnumModule)
-
-      values = meta[:values]
-
-      expect(values).to be_a(Foobara::Enumerated::Values)
-      expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
-
-      expect(values.BAR).to be(:bar)
-      expect(values.BAZ).to be(:baz)
-      expect(values.FOO).to be(:foo)
-    end
-  end
-
-  describe "automatic enumeration module discovery" do
-    let(:klass) do
-      Class.new do
-        include Foobara::Enumerated::Accessors
-
-        enumerated :some_enum
-      end
-    end
-
-    context "when at top-level with expected name" do
-      before do
-        stub_const("SomeEnum", EnumModule)
-      end
-
-      describe ".enumerated_type_metadata" do
-        it "has the right module" do
-          meta = klass.enumerated_type_metadata[:some_enum]
-
-          expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
-          expect(meta[:original_values_source]).to be_nil
-          expect(meta[:values_source]).to be(EnumModule)
-
-          values = meta[:values]
-
-          expect(values).to be_a(Foobara::Enumerated::Values)
-          expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
-
-          expect(values.BAR).to be(:bar)
-          expect(values.BAZ).to be(:baz)
-          expect(values.FOO).to be(:foo)
-        end
-      end
-    end
-
-    context "when in class itself" do
-      let(:klass) do
-        Class.new do
-          const_set("SomeEnum", EnumModule)
-
-          include Foobara::Enumerated::Accessors
-
-          enumerated :some_enum
-        end
-      end
-
-      describe ".enumerated_type_metadata" do
-        it "has the right module" do
-          meta = klass.enumerated_type_metadata[:some_enum]
-
-          expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
-          expect(meta[:original_values_source]).to be_nil
-          expect(meta[:values_source]).to be(EnumModule)
-
-          values = meta[:values]
-
-          expect(values).to be_a(Foobara::Enumerated::Values)
-          expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
-
-          expect(values.BAR).to be(:bar)
-          expect(values.BAZ).to be(:baz)
-          expect(values.FOO).to be(:foo)
-        end
-      end
-    end
-
-    context "when in heirarchy" do
-      let(:mod) do
-        Module.new do
-          const_set("SomeEnum", EnumModule)
-        end
-      end
-
-      let(:klass) do
-        Class.new do
-          class << self
-            def name
-              "Mod::Klass"
-            end
-          end
-
-          include Foobara::Enumerated::Accessors
-
-          enumerated :some_enum
-        end
-      end
-
-      before do
-        stub_const("Mod", mod)
-      end
-
-      describe ".enumerated_type_metadata" do
-        it "has the right module" do
-          meta = klass.enumerated_type_metadata[:some_enum]
-
-          expect(meta.keys).to contain_exactly(:values, :original_values_source, :values_source)
-          expect(meta[:original_values_source]).to be_nil
-          expect(meta[:values_source]).to be(EnumModule)
-
-          values = meta[:values]
-
-          expect(values).to be_a(Foobara::Enumerated::Values)
-          expect(values.all).to eq(BAR: :bar, BAZ: :baz, FOO: :foo)
-
-          expect(values.BAR).to be(:bar)
-          expect(values.BAZ).to be(:baz)
-          expect(values.FOO).to be(:foo)
-        end
-      end
-    end
-  end
-end

data/projects/typesystem/spec/enumerated/enumerated_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe Foobara::Enumerated do
-  describe ".make_module" do
-    let(:mod) { described_class.make_module(*values) }
-
-    let(:values) do
-      [
-        :"foo-bar",
-        :"bar-baz"
-      ]
-    end
-
-    it "has expected constants" do
-      expect(mod::FOO_BAR).to eq(:"foo-bar")
-    end
-
-    it "has delegated methods" do
-      expect(mod.all_values).to match_array(values)
-    end
-
-    context "when passing an array" do
-      let(:mod) { described_class.make_module(values) }
-
-      it "has expected constants" do
-        expect(mod::FOO_BAR).to eq(:"foo-bar")
-      end
-
-      it "has delegated methods" do
-        expect(mod.all_values).to match_array(values)
-      end
-    end
-  end
-end

data/projects/typesystem/spec/enumerated/values_spec.rb

@@ -1,67 +0,0 @@
-RSpec.describe Foobara::Enumerated::Values do
-  let(:values) do
-    described_class.new(enum_declaration)
-  end
-
-  context "when module" do
-    let(:enum_declaration) do
-      Module.new.tap do |m|
-        m.const_set(:FOO, :foo)
-        m.const_set(:BAR, :bar)
-        m.const_set(:BAZ, :baz)
-      end
-    end
-
-    it "constructs the values" do
-      expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
-    end
-  end
-
-  context "when hash" do
-    let(:enum_declaration) do
-      {
-        FOO: :foo,
-        BAR: :bar,
-        BAZ: :baz
-      }
-    end
-
-    it "constructs the values" do
-      expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
-      expect(values.all).to eq(enum_declaration)
-    end
-
-    describe "#value?" do
-      it "is answers if it is a value" do
-        expect(values.value?(:foo)).to be true
-        expect(values.value?(:asdf)).to be false
-      end
-    end
-  end
-
-  context "when array" do
-    let(:enum_declaration) do
-      [
-        :FOO,
-        :BAR,
-        :BAZ
-      ]
-    end
-
-    it "constructs the values" do
-      expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
-      expect(values.all).to eq(enum_declaration.to_h { |key| [key, key] })
-    end
-
-    context "when splatted" do
-      let(:values) do
-        described_class.new(*enum_declaration)
-      end
-
-      it "constructs the values" do
-        expect(values.all_names).to contain_exactly(:FOO, :BAR, :BAZ)
-        expect(values.all).to eq(enum_declaration.to_h { |key| [key, key] })
-      end
-    end
-  end
-end

data/projects/typesystem/spec/foobara/foobara_spec.rb

@@ -1,45 +0,0 @@
-RSpec.describe Foobara do
-  describe ".raise_if_production!" do
-    let(:method_name) { "reset_alls" }
-
-    context "when FOOBARA_ENV is nil" do
-      stub_env_var("FOOBARA_ENV", nil)
-
-      it "raises MethodCantBeCalledInProductionError" do
-        expect {
-          described_class.raise_if_production!(method_name)
-        }.to raise_error(Foobara::MethodCantBeCalledInProductionError)
-      end
-    end
-
-    context "when in production environment" do
-      stub_env_var("FOOBARA_ENV", "production")
-
-      it "raises MethodCantBeCalledInProductionError" do
-        expect {
-          described_class.raise_if_production!(method_name)
-        }.to raise_error(Foobara::MethodCantBeCalledInProductionError)
-      end
-    end
-
-    context "when in test environment" do
-      stub_env_var("FOOBARA_ENV", "test")
-
-      it "doesn't raise MethodCantBeCalledInProductionError" do
-        expect {
-          described_class.raise_if_production!(method_name)
-        }.to_not raise_error
-      end
-    end
-
-    context "when in development environment" do
-      stub_env_var("FOOBARA_ENV", "development")
-
-      it "doesn't raise MethodCantBeCalledInProductionError" do
-        expect {
-          described_class.raise_if_production!(method_name)
-        }.to_not raise_error
-      end
-    end
-  end
-end

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

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