foobara 0.5.10 → 0.6.2

data/projects/typesystem/spec/builtin_types/one_of_spec.rb

@@ -1,73 +0,0 @@
-RSpec.describe Foobara::BuiltinTypes::Duck::SupportedValidators::OneOf do
-  let(:type_declaration) { [:integer, { one_of: }] }
-  let(:one_of) { [1, 3, 5] }
-
-  let(:type) do
-    Foobara::GlobalDomain.foobara_type_from_declaration(*Foobara::Util.array(type_declaration))
-  end
-
-  context "when valid" do
-    it "works as usual" do
-      expect(type.process_value!(5)).to be(5)
-    end
-  end
-
-  context "when allow_nil" do
-    let(:type_declaration) { [:integer, :allow_nil, { one_of: }] }
-
-    it "can be nil" do
-      expect(type.process_value!(nil)).to be_nil
-    end
-  end
-
-  context "when not valid" do
-    it "is not success" do
-      outcome = type.process_value(2)
-
-      expect(outcome).to_not be_success
-
-      expect(outcome.errors_hash).to eq(
-        "data.value_not_valid" => {
-          key: "data.value_not_valid",
-          path: [],
-          runtime_path: [],
-          category: :data,
-          symbol: :value_not_valid,
-          message: "2 is not one of [1, 3, 5]",
-          context: { value: 2, valid_values: [1, 3, 5] },
-          is_fatal: false
-        }
-      )
-    end
-  end
-
-  context "when module" do
-    let(:type_declaration) { [:string, { one_of: }] }
-    let(:one_of) do
-      stub_module "SomeEnum" do
-        const_set(:FOO, :foo)
-        const_set(:BAR, :bar)
-        const_set(:BAZ, :baz)
-      end
-    end
-
-    it "works with expected value" do
-      expect(type.process_value!(:foo)).to eq("foo")
-    end
-
-    context "when not valid" do
-      it "is not success" do
-        expect(type.declaration_data[:one_of]).to contain_exactly("foo", "bar", "baz")
-
-        outcome = type.process_value(:not_valid)
-
-        expect(outcome).to_not be_success
-
-        expect(outcome.errors.size).to eq(1)
-
-        expect(outcome.errors_hash["data.value_not_valid"][:context][:valid_values]).to contain_exactly("baz", "foo",
-                                                                                                        "bar")
-      end
-    end
-  end
-end

data/projects/typesystem/spec/builtin_types/string_spec.rb

@@ -1,117 +0,0 @@
-RSpec.describe ":string" do
-  let(:type) { Foobara::BuiltinTypes[:string] }
-
-  describe "#process!" do
-    subject { type.process_value!(value) }
-
-    context "when string" do
-      let(:value) { "foo" }
-
-      it { is_expected.to eq("foo") }
-    end
-
-    context "when symbol" do
-      let(:value) { :foo }
-
-      it { is_expected.to eq("foo") }
-    end
-
-    context "when not castable" do
-      let(:value) { Object.new }
-
-      it {
-        is_expected_to_raise(
-          Foobara::Value::Processor::Casting::CannotCastError,
-          /Expected it to be a String, be a Numeric, or be a Symbol\z/
-        )
-      }
-    end
-
-    context "with transformers" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(:string, :downcase)
-      end
-
-      context "when uppercase" do
-        let(:value) { "FooBar" }
-
-        it { is_expected.to eq("foobar") }
-      end
-    end
-
-    context "with transformers and empty processor data" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(:string, :downcase, {})
-      end
-
-      context "when uppercase" do
-        let(:value) { "FooBar" }
-
-        it { is_expected.to eq("foobar") }
-      end
-    end
-
-    context "with validators" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(:string, max_length: 10)
-      end
-
-      context "when too long" do
-        let(:value) { "Foo Bar Baz" }
-
-        it {
-          is_expected_to_raise(
-            Foobara::BuiltinTypes::String::SupportedValidators::MaxLength::MaxLengthExceededError,
-            /\b10\b/
-          ) { |error| expect(error.context[:max_length]).to eq(10) }
-        }
-      end
-    end
-
-    context "with :matches validator" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(:string, matches: /bar/i)
-      end
-
-      context "when matches" do
-        let(:value) { "Foo Bar" }
-
-        it { is_expected.to eq(value) }
-      end
-
-      context "when does not match" do
-        let(:value) { "Foo Baz" }
-
-        it {
-          is_expected_to_raise(
-            Foobara::BuiltinTypes::String::SupportedValidators::Matches::DoesNotMatchError,
-            /\/bar\/i\b/
-          ) { |error| expect(error.context[:regex]).to eq(/bar/i.to_s) } # TODO: eliminate this .to_s call
-        }
-      end
-    end
-
-    context "with validators and transformers" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(:string, :downcase, max_length: 10)
-      end
-
-      context "when uppercase" do
-        let(:value) { "FooBar" }
-
-        it { is_expected.to eq("foobar") }
-      end
-
-      context "when too long" do
-        let(:value) { "Foo Bar Baz" }
-
-        it {
-          is_expected_to_raise(
-            Foobara::BuiltinTypes::String::SupportedValidators::MaxLength::MaxLengthExceededError,
-            /\b10\b/
-          ) { |error| expect(error.context[:max_length]).to eq(10) }
-        }
-      end
-    end
-  end
-end

data/projects/typesystem/spec/builtin_types/symbol_spec.rb

@@ -1,24 +0,0 @@
-RSpec.describe ":symbol" do
-  let(:type) { Foobara::BuiltinTypes[:symbol] }
-
-  describe "#process!" do
-    subject { type.process_value!(value) }
-
-    context "when string" do
-      let(:value) { "foo" }
-
-      it { is_expected.to be(:foo) }
-    end
-
-    context "when not castable" do
-      let(:value) { Object.new }
-
-      it {
-        is_expected_to_raise(
-          Foobara::Value::Processor::Casting::CannotCastError,
-          /Expected it to be a Symbol, or be a String\z/
-        )
-      }
-    end
-  end
-end

data/projects/typesystem/spec/builtin_types/tuple_spec.rb

@@ -1,125 +0,0 @@
-RSpec.describe ":tuple" do
-  let(:type) do
-    Foobara::Domain.current.foobara_type_from_declaration(type_declaration)
-  end
-
-  let(:outcome) { type.process_value(value) }
-  let(:errors) { outcome.errors }
-  let(:error) do
-    expect(errors.size).to eq(1)
-    errors.first
-  end
-  let(:result) { outcome.result! }
-
-  let(:type_declaration) do
-    [:big_decimal, { a: :integer }]
-  end
-
-  context "when using array sugar" do
-    describe "#declaration_data" do
-      it "converts to strict type declaration successfully" do
-        expect(type.declaration_data).to eq(
-          type: :tuple,
-          element_type_declarations: [
-            :big_decimal,
-            { type: :attributes, element_type_declarations: { a: :integer } }
-          ],
-          size: 2
-        )
-      end
-
-      context "when array sugar contains a Type" do
-        let(:type_declaration) { [:string, Foobara::BuiltinTypes[:integer], :symbol] }
-
-        it "converts to strict type declaration successfully" do
-          expect(type.declaration_data).to eq(
-            type: :tuple,
-            element_type_declarations: [:string, :integer, :symbol],
-            size: 3
-          )
-        end
-      end
-    end
-
-    describe "#possible_errors" do
-      it "converts to strict type declaration successfully" do
-        expect(type.possible_errors.to_h { |p| [p.key.to_sym, p.error_class] }).to eq(
-          "data.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
-          "data.incorrect_tuple_size": Foobara::BuiltinTypes::Array::SupportedValidators::Size::IncorrectTupleSizeError,
-          "data.0.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
-          "data.1.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
-          "data.1.unexpected_attributes":
-            Foobara::BuiltinTypes::Attributes::SupportedProcessors::ElementTypeDeclarations::UnexpectedAttributesError,
-          "data.1.a.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError
-        )
-      end
-    end
-  end
-
-  context "when using strict hash" do
-    let(:type_declaration) do
-      {
-        type: :tuple,
-        element_type_declarations: [
-          { type: :big_decimal },
-          { type: :attributes, element_type_declarations: { a: { type: :integer } } }
-        ]
-      }
-    end
-
-    describe "#process_value!" do
-      subject { result }
-
-      context "when valid value" do
-        let(:value) { ["3", { a: "2" }] }
-
-        it { is_expected.to eq([BigDecimal(3), { a: 2 }]) }
-      end
-
-      context "when value has too many elements" do
-        let(:value) { ["3", { a: "2" }, :z] }
-
-        it { is_expected_to_raise(Foobara::BuiltinTypes::Array::SupportedValidators::Size::IncorrectTupleSizeError) }
-      end
-
-      context "when an element has an error" do
-        let(:value) { ["3", { a: "not valid" }] }
-
-        it "has error for that element" do
-          expect(error.to_h).to eq(
-            key: "data.1.a.cannot_cast",
-            path: [1, :a],
-            runtime_path: [],
-            category: :data,
-            is_fatal: true,
-            symbol: :cannot_cast,
-            message: 'At 1.a: Cannot cast "not valid" to an integer. Expected it to be a Integer, ' \
-                     "or be a string of digits optionally with a minus sign in front",
-            context: { cast_to: :integer, value: "not valid" }
-          )
-        end
-      end
-    end
-
-    context "when size doesn't match" do
-      let(:type_declaration) { super().merge(size: 3) }
-
-      it "explodes" do
-        expect { type }.to raise_error(
-          Foobara::BuiltinTypes::Tuple::SupportedProcessors::ElementTypeDeclarations::TypeDeclarationExtension::
-              ExtendTupleTypeDeclaration::TypeDeclarationValidators::SizeMatches::IncorrectSizeError
-        )
-      end
-    end
-  end
-
-  describe "#process_value!" do
-    subject { type.process_value!(value) }
-
-    context "when not castable" do
-      let(:value) { Object.new }
-
-      it { is_expected_to_raise(Foobara::Value::Processor::Casting::CannotCastError) }
-    end
-  end
-end

data/projects/typesystem/spec/callback/callback_spec.rb

@@ -1,155 +0,0 @@
-RSpec.describe Foobara::Callback do
-  context "with single multiple action registry" do
-    let(:registry) { Foobara::Callback::Registry::MultipleAction.new(:walk, :jump) }
-
-    let(:calls) { {} }
-
-    def called(action, type, data)
-      for_type = calls[action] ||= {}
-      data_array = for_type[type] ||= []
-      data_array << data
-    end
-
-    before do
-      [:walk, :jump].each do |action|
-        Foobara::Callback::Block.types.each do |type|
-          basic_block = ->(foo) {
-            called(action, type, foo)
-          }
-
-          callback = if type == :around
-                       ->(**opts, &do_it) {
-                         basic_block.call(opts)
-                         do_it.call
-                       }
-                     else
-                       basic_block
-                     end
-
-          registry.register_callback(type, action, &callback)
-        end
-      end
-    end
-
-    describe Foobara::Callback::Runner do
-      let(:runner) { registry.runner(:walk).callback_data(foo: :bar) }
-
-      describe "#run" do
-        context "with a block for a callback type that does not allow a block" do
-          it "raises an error" do
-            expect {
-              registry.register_callback(:before, :walk) { |&block| block.call }
-            }.to raise_error(
-              Foobara::Callback::Block::Concerns::BlockParameterNotAllowed::BlockParameterNotAllowedError
-            )
-          end
-        end
-
-        context "with block" do
-          it "calls expected callbacks in order" do
-            ran = false
-
-            expect(calls).to eq({})
-
-            registry.around(:walk) do |&do_it|
-              expect(calls).to eq(
-                walk: {
-                  before: [{ foo: :bar }]
-                }
-              )
-
-              do_it.call
-
-              expect(calls).to eq(
-                walk: {
-                  before: [{ foo: :bar }],
-                  around: [{ foo: :bar }]
-                }
-              )
-            end
-
-            expect {
-              runner.run { ran = true }
-            }.to change { ran }.from(false).to(true)
-
-            expect(calls).to eq(
-              walk: {
-                before: [{ foo: :bar }],
-                around: [{ foo: :bar }],
-                after: [{ foo: :bar }]
-              }
-            )
-          end
-        end
-
-        context "with any action callback" do
-          before do
-            registry.before(nil) do
-              called(nil, :before, :any_called)
-            end
-          end
-
-          it "calls the any callback on any action" do
-            runner1 = registry.runner(:walk).callback_data(foo: :w)
-            runner2 = registry.runner(:jump).callback_data(foo: :j)
-
-            runner1.run do
-              # empty block
-            end
-            runner2.run do
-              # empty block
-            end
-
-            expect(calls).to eq(
-              {
-                nil => {
-                  before: [:any_called, :any_called]
-                },
-                walk: {
-                  before: [{ foo: :w }],
-                  around: [{ foo: :w }],
-                  after: [{ foo: :w }]
-                },
-                jump: {
-                  before: [{ foo: :j }],
-                  around: [{ foo: :j }],
-                  after: [{ foo: :j }]
-                }
-              }
-            )
-          end
-        end
-
-        context "when error occurs" do
-          let(:kaboom) { Class.new(StandardError) }
-
-          it "calls the any callback on any action" do
-            expect {
-              runner.run do
-                raise kaboom, "Kaboom!"
-              end
-            }.to raise_error(kaboom)
-
-            expect(calls.keys).to eq([:walk])
-            walk = calls[:walk]
-            expect(walk.keys).to eq([:before, :around, :error])
-
-            expect(walk[:before]).to eq([{ foo: :bar }])
-            expect(walk[:around]).to eq([{ foo: :bar }])
-            errors = walk[:error]
-
-            expect(errors.length).to eq(1)
-            error = errors.first
-
-            expect(error).to be_a(runner.class::UnexpectedErrorWhileRunningCallback)
-            expect(error.cause).to be_a(kaboom)
-            expect(error.callback_data).to eq(foo: :bar)
-            expect(error.message).to eq("Kaboom!")
-            expect(error.cause).to be_a(kaboom)
-            expect(error.cause.message).to eq("Kaboom!")
-          end
-        end
-      end
-    end
-  end
-end

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

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