foobara 0.3.0 → 0.4.1

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

@@ -0,0 +1,152 @@
+RSpec.describe Foobara::Callback::Registry::Conditioned do
+  let(:registry) { described_class.new(charge: [:positive, :negative], mass: [:high, :low]) }
+
+  describe "#register_callback" do
+    let(:condition_key) { :charge }
+    let(:condition_value) { :positive }
+    let(:conditions) { { condition_key => condition_value } }
+
+    def register_it
+      registry.after(conditions) { "noop" }
+    end
+
+    context "when given good condition" do
+      it "registers it and can return it even when unioned with other conditions" do
+        expect {
+          register_it
+        }.to change { registry.callback_sets.size }.from(0).to(1)
+
+        registry.unioned_callback_set_for(charge: :positive, mass: nil)
+      end
+    end
+
+    context "when given bad condition key" do
+      let(:condition_key) { :bad_key }
+
+      it "explodes" do
+        expect {
+          register_it
+        }.to raise_error(described_class::InvalidConditions)
+      end
+    end
+
+    context "when given bad condition value" do
+      let(:condition_value) { :bad_value }
+
+      it "explodes" do
+        expect {
+          register_it
+        }.to raise_error(described_class::InvalidConditions)
+      end
+    end
+
+    context "when given nil value" do
+      let(:condition_value) { 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 conditions given" do
+      let(:runner) { registry.runner.callback_data(foo: :bar) }
+
+      describe "#run" do
+        context "with block" do
+          it "calls expected callbacks in order" do
+            ran = false
+            callback_ran = false
+
+            registry.around do |foo:, &do_it|
+              expect(foo).to eq(:bar)
+
+              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 |foo:|
+              expect(foo).to eq(:bar)
+              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 |foo:, &do_it|
+              callbacks_ran << :around_start
+              expect(foo).to eq(:bar)
+
+              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 |foo:|
+              expect(foo).to eq(:bar)
+              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/multiple_action_spec.rb

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

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

@@ -0,0 +1,270 @@
+require "ostruct"
+
+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
+    # rubocop:disable Style/OpenStructUse
+    let(:object) do
+      [
+        {
+          a: {
+            b: [1, 2, { c: 4 }],
+            d: OpenStruct.new
+          }
+        },
+        "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: OpenStruct.new
+              }
+            },
+            "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: OpenStruct.new
+              }
+            },
+            "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: OpenStruct.new(z: 200)
+              }
+            },
+            "whatever"
+          ]
+        )
+      end
+    end
+    # rubocop:enable Style/OpenStructUse
+  end
+end