foobara 0.3.0 → 0.4.1

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

@@ -0,0 +1,59 @@
+RSpec.describe ":float" do
+  let(:type) { Foobara::BuiltinTypes[:float] }
+
+  describe "caster names" do
+    it "gives the names of the casters including the dynamically generated class matcher" do
+      expect(type.value_caster.processor_names).to contain_exactly("Foobara::BuiltinTypes::Float::Casters::Integer", "Foobara::BuiltinTypes::Float::Casters::String")
+    end
+  end
+
+  describe "#needs_cast?" do
+    subject { type.needs_cast?(value) }
+
+    context "when Float" do
+      let(:value) { 1.3 }
+
+      it { is_expected.to be(false) }
+    end
+
+    context "when something else" do
+      let(:value) { Object.new }
+
+      it { is_expected.to be(true) }
+    end
+  end
+
+  describe "#process!" do
+    subject { type.process_value!(value) }
+
+    context "when ::Float" do
+      let(:value) { 1.3 }
+
+      it { is_expected.to be(value) }
+    end
+
+    context "when ::Integer" do
+      let(:value) { 10 }
+
+      it { is_expected.to be(10.to_f) }
+    end
+
+    context "when '1.3'" do
+      let(:value) { "1.3" }
+
+      it { is_expected.to be(1.3) }
+    end
+
+    context "when '-1.3E-5'" do
+      let(:value) { "-1.3E-5" }
+
+      it { is_expected.to be(-0.000013) }
+    end
+
+    context "when not castable" do
+      let(:value) { "notcastable" }
+
+      it { is_expected_to_raise(Foobara::Value::Processor::Casting::CannotCastError) }
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+RSpec.describe Foobara::BuiltinTypes::Duck::SupportedValidators::OneOf do
+  let(:type) do
+    Foobara::GlobalDomain.foobara_type_from_declaration(*Foobara::Util.array(type_declaration))
+  end
+
+  before do
+    stub_class("Foo")
+  end
+
+  context "when class" do
+    let(:type_declaration) { Foo }
+
+    it "desugarizes as a duck and works as a duck but validates instance of" do
+      expect(type.declaration_data).to eq(type: :duck, instance_of: "Foo")
+
+      foo = Foo.new
+      expect(type.process_value!(foo)).to be(foo)
+
+      not_foo = Object.new
+      outcome = type.process_value(not_foo)
+      expect(outcome).to_not be_success
+      errors = outcome.errors
+      expect(errors.size).to eq(1)
+      error = errors.first
+      expect(error).to be_a(Foobara::BuiltinTypes::Duck::SupportedValidators::InstanceOf::NotInstanceOfError)
+      expect(error.message).to match(/is not an instance of Foo/)
+    end
+  end
+
+  context "when :duck with instance_of: processor declaration" do
+    let(:type_declaration) do
+      [:duck, { instance_of: :Foo }]
+    end
+
+    it "casts instance_of: to a string" do
+      expect(type.declaration_data).to eq(type: :duck, instance_of: "Foo")
+    end
+
+    context "when intance_of: some class" do
+      let(:type_declaration) do
+        [:duck, { instance_of: Foo }]
+      end
+
+      it "casts instance_of: to a string" do
+        expect(type.declaration_data).to eq(type: :duck, instance_of: "Foo")
+      end
+    end
+  end
+
+  context "when not the name of an existing class" do
+    let(:type_declaration) do
+      [:duck, { instance_of: "NotAnExistingClassName" }]
+    end
+
+    it "explodes" do
+      expect {
+        type
+      }.to raise_error(Foobara::BuiltinTypes::Duck::SupportedValidators::InstanceOf::TypeDeclarationExtension::
+          ExtendRegisteredTypeDeclaration::TypeDeclarationValidators::IsValidClass::InvalidInstanceOfValueGivenError)
+    end
+  end
+
+  context "when not something that can be desugarized at all" do
+    let(:type_declaration) do
+      [:duck, { instance_of: 100 }]
+    end
+
+    it "explodes" do
+      expect {
+        type
+      }.to raise_error(Foobara::BuiltinTypes::Duck::SupportedValidators::InstanceOf::TypeDeclarationExtension::
+          ExtendRegisteredTypeDeclaration::TypeDeclarationValidators::IsValidClass::InvalidInstanceOfValueGivenError)
+    end
+  end
+end

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

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

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

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

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

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