foobara 0.5.10 → 0.6.2

data/projects/typesystem/spec/callback/registry/multiple_action_spec.rb

@@ -1,144 +0,0 @@
-RSpec.describe Foobara::Callback::Registry::MultipleAction do
-  let(:registry) { described_class.new(possible_actions) }
-  let(:possible_actions) { [:run, :walk] }
-
-  describe "#register_callback" do
-    let(:action) { :run }
-
-    def register_it
-      registry.after(action) { "noop" }
-    end
-
-    context "when given good action" do
-      it "registers it and can return it even when unioned with other actions" do
-        expect {
-          register_it
-        }.to change { registry.callback_sets.size }.from(0).to(1)
-
-        set = registry.unioned_callback_set_for(:run)
-        expect(set.size).to eq(1)
-        set = registry.unioned_callback_set_for(nil)
-        expect(set.size).to eq(1)
-        set = registry.unioned_callback_set_for(:walk)
-        expect(set.size).to eq(0)
-        expect {
-          registry.unioned_callback_set_for(:bad_symbol)
-        }.to raise_error(described_class::InvalidAction)
-      end
-    end
-
-    context "when given bad action" do
-      let(:action) { :bad_key }
-
-      it "explodes" do
-        expect {
-          register_it
-        }.to raise_error(described_class::InvalidAction)
-      end
-    end
-
-    context "when given nil value" do
-      let(:action) { nil }
-
-      it "is fine" do
-        expect {
-          register_it
-        }.to change { registry.callback_sets.size }.from(0).to(1)
-      end
-    end
-  end
-
-  describe "#runner" do
-    context "when no action given" do
-      let(:runner) { registry.runner }
-
-      describe "#run" do
-        context "with block" do
-          it "calls expected callbacks in order" do
-            ran = false
-            callback_ran = false
-
-            registry.around do |&do_it|
-              do_it.call
-
-              callback_ran = true
-            end
-
-            expect {
-              runner.run { ran = true }
-            }.to change { ran }.from(false).to(true)
-
-            expect(callback_ran).to be(true)
-          end
-        end
-
-        context "with blocks" do
-          let(:callbacks_ran) { [] }
-
-          before do
-            expect(registry).to_not have_before_callbacks
-            expect(registry).to_not have_around_callbacks
-            expect(registry).to_not have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.before do
-              callbacks_ran << :before
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to_not have_around_callbacks
-            expect(registry).to_not have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.around do |&do_it|
-              callbacks_ran << :around_start
-
-              do_it.call
-
-              callbacks_ran << :around_end
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to have_around_callbacks
-            expect(registry).to_not have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.after  do
-              callbacks_ran << :after
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to have_around_callbacks
-            expect(registry).to have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.error do |error|
-              expect(error).to be_a(Foobara::Callback::Runner::UnexpectedErrorWhileRunningCallback)
-              expect(error.message).to eq("kaboom!")
-
-              callbacks_ran << :error
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to have_around_callbacks
-            expect(registry).to have_after_callbacks
-            expect(registry).to have_error_callbacks
-          end
-
-          it "calls expected callbacks in order" do
-            runner.run { "noop" }
-
-            expect(callbacks_ran).to eq([:before, :around_start, :around_end, :after])
-            callbacks_ran.clear
-
-            expect {
-              runner.run { raise "kaboom!" }
-            }.to raise_error(RuntimeError)
-
-            expect(callbacks_ran).to eq([:before, :around_start, :error])
-          end
-        end
-      end
-    end
-  end
-end

data/projects/typesystem/spec/callback/registry/single_action_spec.rb

@@ -1,114 +0,0 @@
-RSpec.describe Foobara::Callback::Registry::SingleAction do
-  let(:registry) { described_class.new }
-
-  describe "#register_callback" do
-    def register_it
-      registry.after { "noop" }
-    end
-
-    context "when given good action" do
-      it "registers it and can return it even when unioned with other actions" do
-        expect {
-          register_it
-        }.to change { registry.specific_callback_set_for.size }.from(0).to(1)
-
-        set = registry.unioned_callback_set_for
-        expect(set.size).to eq(1)
-      end
-    end
-  end
-
-  describe "#runner" do
-    context "when no action given" do
-      let(:runner) { registry.runner }
-
-      describe "#run" do
-        context "with block" do
-          it "calls expected callbacks in order" do
-            ran = false
-            callback_ran = false
-
-            registry.around do |&do_it|
-              do_it.call
-
-              callback_ran = true
-            end
-
-            expect {
-              runner.run { ran = true }
-            }.to change { ran }.from(false).to(true)
-
-            expect(callback_ran).to be(true)
-          end
-        end
-
-        context "with blocks" do
-          let(:callbacks_ran) { [] }
-
-          before do
-            expect(registry).to_not have_before_callbacks
-            expect(registry).to_not have_around_callbacks
-            expect(registry).to_not have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.before do
-              callbacks_ran << :before
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to_not have_around_callbacks
-            expect(registry).to_not have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.around do |&do_it|
-              callbacks_ran << :around_start
-
-              do_it.call
-
-              callbacks_ran << :around_end
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to have_around_callbacks
-            expect(registry).to_not have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.after  do
-              callbacks_ran << :after
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to have_around_callbacks
-            expect(registry).to have_after_callbacks
-            expect(registry).to_not have_error_callbacks
-
-            registry.error do |error|
-              expect(error).to be_a(Foobara::Callback::Runner::UnexpectedErrorWhileRunningCallback)
-              expect(error.message).to eq("kaboom!")
-
-              callbacks_ran << :error
-            end
-
-            expect(registry).to have_before_callbacks
-            expect(registry).to have_around_callbacks
-            expect(registry).to have_after_callbacks
-            expect(registry).to have_error_callbacks
-          end
-
-          it "calls expected callbacks in order" do
-            runner.run { "noop" }
-
-            expect(callbacks_ran).to eq([:before, :around_start, :around_end, :after])
-            callbacks_ran.clear
-
-            expect {
-              runner.run { raise "kaboom!" }
-            }.to raise_error(RuntimeError)
-
-            expect(callbacks_ran).to eq([:before, :around_start, :error])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,268 +0,0 @@
-RSpec.describe Foobara::DataPath do
-  let(:key) { described_class.new(path) }
-
-  let(:category) { "some_category" }
-  let(:path) { "some_path" }
-  let(:runtime_path) { "some_runtime_path" }
-  let(:symbol) { "some_symbol" }
-
-  describe ".prepend_path" do
-    let(:new_parts) { [:path1, :path2] }
-
-    context "when DataPath" do
-      subject { described_class.prepend_path(key, new_parts) }
-
-      it { is_expected.to eq(described_class.parse("path1.path2.some_path")) }
-    end
-
-    context "when string" do
-      subject { described_class.prepend_path(path, new_parts) }
-
-      it { is_expected.to eq(described_class.parse("path1.path2.some_path").to_s) }
-    end
-  end
-
-  describe ".append_path" do
-    let(:new_parts) { [:path1, :path2] }
-
-    context "when DataPath" do
-      subject { described_class.append_path(key, new_parts) }
-
-      it { is_expected.to eq(described_class.parse("some_path.path1.path2")) }
-    end
-
-    context "when string" do
-      subject { described_class.append_path(path, new_parts) }
-
-      it { is_expected.to eq(described_class.parse("some_path.path1.path2").to_s) }
-    end
-  end
-
-  describe ".to_s_type" do
-    it "changes integer indices to pound sign" do
-      expect(described_class.to_s_type("a.0.b")).to eq("a.#.b")
-    end
-  end
-
-  describe "#to_sym" do
-    it "just calls #to_sym on the string path" do
-      expect(described_class.new([:a, :b]).to_sym).to eq(:"a.b")
-    end
-  end
-
-  describe ".values_at" do
-    subject { described_class.values_at(path, object) }
-
-    context "when nested with two indices" do
-      let(:path) { [:foo, :bar, :"#", :foo, :chars, 2] }
-
-      let(:object) do
-        Struct.new(:foo).new.tap do |o|
-          o.foo = {
-            bar: [
-              {
-                foo: "bar",
-                foo2: "junk"
-              },
-              {
-                foo: "baz"
-              }
-            ]
-          }
-        end
-      end
-
-      it { is_expected.to eq(["r", "z"]) }
-
-      context "when object has strings instead of symbols" do
-        before do
-          bar = object.foo.delete(:bar)
-          expect(bar).to be_an(Array)
-
-          object.foo["bar"] = bar
-        end
-
-        it { is_expected.to eq(["r", "z"]) }
-      end
-    end
-  end
-
-  describe ".value_at" do
-    let(:object) do
-      Struct.new(:foo).new.tap do |o|
-        o.foo = {
-          bar: [
-            {
-              foo: "bar"
-            }
-          ]
-        }
-      end
-    end
-
-    let(:path) { [:foo, :bar, 0, :foo, :chars, 2] }
-    let(:value) { described_class.value_at(path, object) }
-
-    it "can find the relevant value" do
-      expect(value).to eq("r")
-    end
-
-    context "when using strings in the path instead of symbols" do
-      # Hmmmm... mildly surprising that this works with "2" instead of 2 but that's likely desirable.
-      let(:path) { super().map(&:to_s) }
-
-      it "can find the relevant value" do
-        expect(value).to eq("r")
-      end
-    end
-
-    context "when there's more than one value at the path" do
-      let(:object) do
-        Struct.new(:foo).new.tap do |o|
-          o.foo = {
-            bar: [
-              {
-                foo: "bar"
-              },
-              {
-                foo: "baz"
-              }
-            ]
-          }
-        end
-      end
-
-      let(:path) { [:foo, :bar, :"#", :foo, :chars, 2] }
-
-      it "raises TooManyValuesAtPathError" do
-        expect { described_class.value_at(path, object) }.to raise_error(described_class::TooManyValuesAtPathError)
-      end
-    end
-
-    context "when path is empty string" do
-      let(:path) { "" }
-      let(:object) { 1 }
-
-      it "returns the object itself" do
-        expect(described_class.value_at(path, object)).to eq(object)
-      end
-    end
-  end
-
-  describe "#simple_collection?" do
-    subject { described_class.new(path).simple_collection? }
-
-    context "when not a collection" do
-      let(:path) { [:foo, :bar] }
-
-      it { is_expected.to be(false) }
-    end
-
-    context "when not simple" do
-      let(:path) { [:foo, :"#", :bar, :"#"] }
-
-      it { is_expected.to be(false) }
-    end
-
-    context "when simple and a collection" do
-      let(:path) { [:foo, :bar, :baz, :"#"] }
-
-      it { is_expected.to be(true) }
-    end
-  end
-
-  describe ".set_value_at" do
-    let(:some_struct) { Struct.new(:z) }
-
-    let(:object) do
-      [
-        {
-          a: {
-            b: [1, 2, { c: 4 }],
-            d: some_struct.new("zz")
-          }
-        },
-        "whatever"
-      ]
-    end
-
-    context "when changing value of a hash" do
-      let(:path) { [0, :a, :b, 2, :c] }
-
-      it "can dig through the structure and set the value" do
-        described_class.set_value_at(object, 100, path)
-
-        expect(object).to eq(
-          [
-            {
-              a: {
-                b: [1, 2, { c: 100 }],
-                d: some_struct.new("zz")
-              }
-            },
-            "whatever"
-          ]
-        )
-      end
-    end
-
-    context "when changing value of a hash indifferently" do
-      let(:object) do
-        {
-          "a" => {
-            "b" => 10
-          }
-        }
-      end
-      let(:path) { ["a", "b"] }
-
-      it "can dig through the structure and set the value" do
-        described_class.set_value_at(object, 100, path)
-
-        expect(object).to eq("a" => { "b" => 100 })
-      end
-    end
-
-    context "when changing an array element" do
-      let(:path) { [0, :a, :b, 1] }
-
-      it "can dig through the structure and set the value" do
-        described_class.set_value_at(object, 100, path)
-
-        expect(object).to eq(
-          [
-            {
-              a: {
-                b: [1, 100, { c: 4 }],
-                d: some_struct.new("zz")
-              }
-            },
-            "whatever"
-          ]
-        )
-      end
-    end
-
-    context "when changing via method" do
-      let(:path) { [0, :a, :d, :z] }
-
-      it "can dig through the structure and set the value" do
-        object[0][:a][:d].z = 15
-
-        described_class.set_value_at(object, 200, path)
-
-        expect(object).to eq(
-          [
-            {
-              a: {
-                b: [1, 2, { c: 4 }],
-                d: some_struct.new(200)
-              }
-            },
-            "whatever"
-          ]
-        )
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-RSpec.describe Foobara::ErrorCollection do
-  let(:error_collection) { described_class.new }
-
-  describe "#success?" do
-    context "when no errors" do
-      it { is_expected.to be_success }
-    end
-  end
-
-  describe "#add_error" do
-    let(:symbol) { :s }
-    let(:message) { "m" }
-    let(:context) { { foo: :bar } }
-
-    let(:error_class) do
-      Foobara::Error.subclass(symbol:, message:, context: { foo: :symbol }, is_fatal: true)
-    end
-    let(:error) { error_class.new(context:) }
-
-    context "when adding error instance" do
-      it "creates and adds an error" do
-        expect(error_collection).to be_empty
-
-        error_collection.add_error(error)
-
-        expect(error_collection).to_not be_empty
-        expect(error_collection.size).to eq(1)
-        error = error_collection.first
-        expect(error).to be_a(Foobara::Error)
-        expect(error.is_fatal).to be(true)
-        expect(error.symbol).to eq(symbol)
-        expect(error.message).to eq(message)
-        expect(error.context).to eq(context)
-      end
-    end
-
-    # Do we really need to support this?
-    context "when adding error by hash" do
-      around do |example|
-        Foobara::TypeDeclarations.with_validate_error_context_disabled do
-          example.run
-        end
-      end
-
-      let(:error_hash) do
-        {
-          symbol:,
-          message:,
-          context:
-        }
-      end
-
-      it "creates and adds an error" do
-        expect(error_collection).to be_empty
-
-        error_collection.add_error(error_hash)
-
-        expect(error_collection).to_not be_empty
-        expect(error_collection.size).to eq(1)
-        error = error_collection.first
-        expect(error).to be_a(Foobara::Error)
-        expect(error.symbol).to eq(symbol)
-        expect(error.message).to eq(message)
-        expect(error.context).to eq(context)
-      end
-    end
-
-    context "when passing the same error twice" do
-      it "explodes" do
-        error_collection.add_error(error)
-        expect {
-          error_collection.add_error(error)
-        }.to raise_error(described_class::ErrorAlreadySetError)
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-RSpec.describe Foobara::ErrorKey do
-  let(:key) { described_class.new(category:, path:, runtime_path:, symbol:) }
-
-  let(:category) { "some_category" }
-  let(:path) { "some_path" }
-  let(:runtime_path) { "some_runtime_path" }
-  let(:symbol) { "some_symbol" }
-
-  describe ".prepend_path" do
-    subject { described_class.prepend_path(key, new_parts) }
-
-    let(:new_parts) { [:path1, :path2] }
-
-    context "when ErrorKey" do
-      it { is_expected.to eq("some_runtime_path>some_category.path1.path2.some_path.some_symbol") }
-    end
-
-    context "when String" do
-      let(:key) { super().to_s }
-
-      it { is_expected.to eq("some_runtime_path>some_category.path1.path2.some_path.some_symbol") }
-    end
-  end
-
-  describe ".prepend_runtime_path" do
-    subject { described_class.prepend_runtime_path(key, new_parts) }
-
-    let(:new_parts) { [:path1, :path2] }
-
-    context "when ErrorKey" do
-      it { is_expected.to eq("path1>path2>some_runtime_path>some_category.some_path.some_symbol") }
-    end
-
-    context "when String" do
-      let(:key) { super().to_s }
-
-      it { is_expected.to eq("path1>path2>some_runtime_path>some_category.some_path.some_symbol") }
-    end
-  end
-
-  describe ".to_h" do
-    subject { described_class.to_h(key) }
-
-    let(:key) { "path1>path2>some_category.some_path.some_symbol" }
-    let(:expected_hash) do
-      {
-        category: :some_category,
-        runtime_path: [:path1, :path2],
-        path: [:some_path],
-        symbol: :some_symbol
-      }
-    end
-
-    it { is_expected.to eq(expected_hash) }
-  end
-end