foobara 0.5.10 → 0.6.2

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

@@ -1,430 +0,0 @@
-RSpec.describe "custom types" do
-  context "when defining a custom complex type" do
-    after do
-      Foobara.reset_alls
-    end
-
-    let(:complex_class) do
-      stub_class :CustomComplex do
-        attr_accessor :real, :imaginary
-      end
-    end
-
-    let(:type_declaration) do
-      {
-        type: :attributes,
-        element_type_declarations: {
-          n: :integer,
-          # not entirely complex since we only support integers for the components for now but whatever
-          c: { type: :custom_complex, be_pointless: :true_symbol }
-        }
-      }
-    end
-    let(:type) { type_builder.type_for_declaration(type_declaration) }
-
-    let(:type_declaration_handler) { type_builder.type_declaration_handler_for(type_declaration) }
-    let(:type_declaration_handler_class) do
-      custom_caster = array_to_complex_caster.new
-      klass = complex_class
-
-      pointless = pointless_validator
-
-      stub_class :ComplexTypeDeclarationHandler, Foobara::TypeDeclarations::TypeDeclarationHandler do
-        class << self
-          def sugar_for_complex?(sugary_type_declaration)
-            sugary_type_declaration = sugary_type_declaration.declaration_data
-
-            if sugary_type_declaration.is_a?(Symbol)
-              sugary_type_declaration = sugary_type_declaration.to_s
-            end
-
-            if sugary_type_declaration.is_a?(String)
-              @complex_form_regex ||= /\A([a-z])\s*\+\s*(?!\1)([a-z])i\z/
-
-              @complex_form_regex.match?(sugary_type_declaration)
-            end
-          end
-        end
-
-        def applicable?(sugary_type_declaration)
-          (sugary_type_declaration.hash? && sugary_type_declaration[:type] == :custom_complex) ||
-            sugar_for_complex?(sugary_type_declaration)
-        end
-
-        define_method :desugarizers do
-          [
-            ComplexTypeDeclarationHandler::SomeDesugarizer.instance
-          ]
-        end
-
-        def sugar_for_complex?(sugary_type_declaration)
-          self.class.sugar_for_complex?(sugary_type_declaration)
-        end
-      end
-
-      stub_class "ComplexTypeDeclarationHandler::SomeDesugarizer", Foobara::TypeDeclarations::Desugarizer do
-        def applicable?(value)
-          ComplexTypeDeclarationHandler.sugar_for_complex?(value)
-        end
-
-        def desugarize(_value)
-          declaration = Foobara::TypeDeclaration.new(type: :custom_complex)
-
-          declaration.is_strict = true
-          declaration.is_duped = true
-          declaration.is_deep_duped = true
-
-          declaration
-        end
-      end
-
-      stub_class "ComplexTypeDeclarationHandler::ToTypeTransformer", Foobara::TypeDeclarations::ToTypeTransformer do
-        define_method :transform do |strict_type_declaration|
-          be_pointless = strict_type_declaration[:be_pointless]
-
-          validators = be_pointless ? [pointless.new(be_pointless)] : []
-
-          type = Foobara::Types::Type.new(
-            strict_type_declaration,
-            base_type: Foobara::Namespace.global.foobara_lookup_type!(:number),
-            name: :custom_complex,
-            transformers: [],
-            validators:,
-            element_processors: nil,
-            target_classes: klass
-          )
-
-          type.add_caster(custom_caster)
-
-          type
-        end
-      end
-
-      ComplexTypeDeclarationHandler
-    end
-
-    let(:array_to_complex_caster) do
-      klass = complex_class
-
-      stub_class :SomeCaster, Foobara::Value::Caster do
-        def applicable?(value)
-          value.is_a?(Array) && value.size == 2
-        end
-
-        define_method :cast do |(real, imaginary)|
-          complex = klass.new
-
-          complex.real = real
-          complex.imaginary = imaginary
-
-          complex
-        end
-      end
-    end
-
-    let(:pointless_validator) do
-      stub_class :PointlessValidator, Foobara::Value::Validator do
-        class << self
-          def symbol
-            :be_pointless
-          end
-        end
-
-        def be_pointless
-          declaration_data
-        end
-
-        def validation_errors(complex)
-          # :nocov:
-          return unless be_pointless == :true_symbol
-
-          # :nocov:
-
-          if complex.real == complex.imaginary
-            build_error
-          end
-        end
-      end
-
-      stub_class "PointlessValidator::Error", Foobara::Value::DataError do
-        message "cant be the same!"
-        context foo: :symbol
-        symbol :real_should_not_match_imaginary
-
-        class << self
-          def context
-            { foo: :bar }
-          end
-        end
-      end
-
-      PointlessValidator
-    end
-
-    let(:domain) do
-      stub_module :CustomTypeSpec do
-        foobara_domain!
-      end
-    end
-
-    let(:type_builder) do
-      domain.foobara_type_builder
-    end
-
-    def in_namespace(&)
-      Foobara::Namespace.use(domain, &)
-    end
-
-    before do
-      type_builder.register_type_declaration_handler(type_declaration_handler_class.new)
-    end
-
-    context "when type declaration invalid" do
-      let(:type_declaration) do
-        :"x + yi"
-      end
-
-      let(:type_declaration_handler) { type_declaration_handler_class.new }
-      let(:type_declaration_validator_class) {
-        stub_class :WhateverValidator, Foobara::TypeDeclarations::TypeDeclarationValidator do
-          def validation_errors(_value)
-            [build_error]
-          end
-
-          def error_context(_value)
-            { foo: :bar }
-          end
-        end
-
-        stub_class "WhateverValidator::WhateverError", Foobara::Value::DataError do
-          class << self
-            def message
-              "whatevs!"
-            end
-
-            def context_type_declaration
-              { foo: :symbol }
-            end
-          end
-        end
-
-        WhateverValidator
-      }
-
-      before do
-        validator = type_declaration_validator_class.instance
-        ComplexTypeDeclarationHandler.define_method :type_declaration_validators do
-          [validator]
-        end
-      end
-
-      it "cannot get a type from the type declaration handler" do
-        outcome = type_declaration_handler.process_value(Foobara::TypeDeclaration.new(type_declaration))
-
-        expect(outcome).to_not be_success
-
-        # TODO: why isn't errors an error collection??
-        expect(outcome.errors_hash).to eq(
-          "data.whatever" => {
-            category: :data,
-            key: "data.whatever",
-            path: [],
-            runtime_path: [],
-            is_fatal: false,
-            context: { foo: :bar },
-            message: "whatevs!",
-            symbol: :whatever
-          }
-        )
-      end
-    end
-
-    context "when using the type against valid data from complex type non sugar type declaration" do
-      around do |example|
-        in_namespace { example.run }
-      end
-
-      before do
-        type.register_supported_processor_class(pointless_validator)
-      end
-
-      context "when valid" do
-        it "can process the thing" do
-          value = type.process_value!(n: 5, c: [1, 2])
-
-          complex = value[:c]
-
-          expect(complex).to be_a(complex_class)
-          expect(complex.real).to eq(1)
-          expect(complex.imaginary).to eq(2)
-        end
-
-        describe "#remove_processor_by_symbol" do
-          it "removes all processors with the given symbol" do
-            expect(type.processors.last.processors.map(&:symbol)).to include(:element_type_declarations)
-            expect(type.element_processors.map(&:symbol)).to include(:element_type_declarations)
-
-            type.remove_processor_by_symbol(:element_type_declarations)
-
-            expect(type.processors.last.processors.map(&:symbol)).to_not include(:element_type_declarations)
-            expect(type.element_processors.map(&:symbol)).to_not include(:element_type_declarations)
-          end
-        end
-      end
-
-      context "when invalid" do
-        it "can process the thing" do
-          outcome = in_namespace { type.process_value(n: 5, c: [2, 2]) }
-
-          expect(outcome).to_not be_success
-          errors = outcome.errors
-
-          expect(errors.size).to eq(1)
-          error = errors.first
-          expect(error.to_h).to eq(
-            category: :data,
-            key: "data.c.real_should_not_match_imaginary",
-            path: [:c],
-            runtime_path: [],
-            is_fatal: false,
-            symbol: :real_should_not_match_imaginary,
-            context: { foo: :bar },
-            message: "cant be the same!"
-          )
-        end
-      end
-    end
-
-    context "when using the type against valid data from complex type sugar type declaration" do
-      let(:type_declaration) do
-        {
-          type: :attributes,
-          element_type_declarations: {
-            n: :integer,
-            c: :"x + yi"
-          }
-        }
-      end
-
-      context "when valid" do
-        around do |example|
-          in_namespace { example.run }
-        end
-
-        it "can process the thing" do
-          value = type.process_value!(n: 5, c: [1, 2])
-          complex = value[:c]
-
-          expect(complex).to be_a(complex_class)
-          expect(complex.real).to eq(1)
-          expect(complex.imaginary).to eq(2)
-        end
-      end
-    end
-
-    context "when registering type" do
-      describe "#type_for_declaration" do
-        context "when not registered" do
-          it "raises" do
-            expect {
-              type_builder.type_for_declaration(:custom_complex)
-            }.to raise_error(Foobara::TypeDeclarations::TypeBuilder::NoTypeDeclarationHandlerFoundError)
-          end
-        end
-
-        context "when registered" do
-          let(:type_declaration_handler) { type_declaration_handler_class.new }
-          let(:type) do
-            type_declaration_handler.process_value!(
-              Foobara::TypeDeclaration.new(type: :custom_complex, be_pointless: :true_symbol)
-            )
-          end
-
-          before do
-            # TODO: make this less awkward...
-            type.type_symbol = :custom_complex
-            Foobara::GlobalDomain.foobara_register(type)
-          end
-
-          it "gives the complex type for the complex symbol" do
-            expect(type_builder.type_for_declaration(:custom_complex)).to be(type)
-          end
-
-          it "can cast if needed" do
-            # TODO: this is very confusing.
-            # Maybe call this complex type? Too much nested behavior being tested in this test.
-            outcome = type.cast([100, 200])
-
-            expect(outcome).to be_success
-            value = outcome.result
-            expect(value.real).to eq(100)
-            expect(value.imaginary).to eq(200)
-          end
-
-          it "can give validation_errors if needed" do
-            errors = type.validation_errors([-40, -40])
-            expect(Foobara::ErrorCollection.to_h(errors)).to eq(
-              "data.real_should_not_match_imaginary" => {
-                key: "data.real_should_not_match_imaginary",
-                path: [],
-                runtime_path: [],
-                is_fatal: false,
-                category: :data,
-                symbol: :real_should_not_match_imaginary,
-                message: "cant be the same!",
-                context: { foo: :bar }
-              }
-            )
-          end
-
-          context "with a transformer" do
-            let(:transformer_class) do
-              stub_class :SomeTransformer, Foobara::TypeDeclarations::Transformer do
-                def always_applicable?
-                  true
-                end
-
-                def transform(value)
-                  value
-                end
-              end
-            end
-
-            let(:transformer) { transformer_class.instance }
-
-            before do
-              type.transformers << transformer
-            end
-
-            it "can give validation_errors if needed" do
-              errors = type.validation_errors([-40, -40])
-
-              expect(Foobara::ErrorCollection.to_h(errors)).to eq(
-                "data.real_should_not_match_imaginary" => {
-                  key: "data.real_should_not_match_imaginary",
-                  path: [],
-                  runtime_path: [],
-                  is_fatal: false,
-                  category: :data,
-                  symbol: :real_should_not_match_imaginary,
-                  message: "cant be the same!",
-                  context: { foo: :bar }
-                }
-              )
-            end
-
-            context "when no errors" do
-              before do
-                type.validators = []
-              end
-
-              it "is empty" do
-                expect(type.validation_errors([2, -40])).to eq([])
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-RSpec.describe ":date" do
-  let(:type) { Foobara::BuiltinTypes[:date] }
-
-  describe "#process!" do
-    subject { type.process_value!(value) }
-
-    context "when ::Date" do
-      let(:value) { Date.new(2020, 1, 2) }
-
-      it { is_expected.to be(value) }
-    end
-
-    context "when ::Hash" do
-      let(:value) { { year: 2020, month: 1, day: 2 } }
-
-      it { is_expected.to eq(Date.new(2020, 1, 2)) }
-    end
-
-    context "when '20200102'" do
-      let(:value) { "20200102" }
-
-      it { is_expected.to eq(Date.new(2020, 1, 2)) }
-    end
-
-    context "when '2020-01-2'" do
-      let(:value) { "2020-01-2" }
-
-      it { is_expected.to eq(Date.new(2020, 1, 2)) }
-    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/datetime_spec.rb

@@ -1,49 +0,0 @@
-RSpec.describe ":datetime" do
-  let(:type) { Foobara::BuiltinTypes[:datetime] }
-
-  describe "#process!" do
-    subject { type.process_value!(value) }
-
-    context "when ::Time" do
-      let(:value) { Time.new(2020, 1, 2, 3, 4, 5, 6) }
-
-      it { is_expected.to be(value) }
-    end
-
-    context "when ::Date" do
-      let(:value) { Date.new(2020, 1, 2) }
-
-      it { is_expected.to eq(Time.new(2020, 1, 2)) }
-    end
-
-    context "when ::Hash" do
-      let(:value) { { year: "2020", month: 1, day: 2, hours: 3, minutes: 4, seconds: 5 } }
-
-      it { is_expected.to eq(Time.new(2020, 1, 2, 3, 4, 5)) }
-
-      context "with milliseconds" do
-        let(:value) { { year: "2020", month: 1, day: 2, hours: 3, minutes: 4, seconds: 5, milliseconds: 500 } }
-
-        it { is_expected.to eq(Time.new(2020, 1, 2, 3, 4, 5.5)) }
-      end
-
-      context "with zone" do
-        let(:value) { { year: "2020", month: 1, day: 2, hours: 3, minutes: 4, seconds: 5, zone: "-0700" } }
-
-        it { is_expected.to eq(Time.new(2020, 1, 2, 3, 4, 5, in: "-0700")) }
-      end
-    end
-
-    context "when '2020-01-02 03:04:05.500 -1200'" do
-      let(:value) { "2020-01-02 03:04:05.500 -1200" }
-
-      it { is_expected.to eq(Time.new(2020, 1, 2, 3, 4, 5.5, in: "-12:00")) }
-    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/email_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe ":email" do
-  let(:type) { Foobara::BuiltinTypes[:email] }
-
-  describe "#process!" do
-    subject { type.process_value!(value) }
-
-    context "when valid string" do
-      let(:value) { "foo@bar.baz" }
-
-      it { is_expected.to eq("foo@bar.baz") }
-    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/
-        )
-      }
-    end
-
-    context "when uppercase" do
-      let(:value) { "FooBar@examPLE.com" }
-
-      it { is_expected.to eq("foobar@example.com") }
-    end
-
-    context "when too long" do
-      let(:value) { "#{"a" * 70}@example.com" }
-
-      it {
-        is_expected_to_raise(
-          Foobara::BuiltinTypes::Email::Validators::CannotExceed64Characters.error_class,
-          # TODO: this is goofy that it doesn't put a space before 64. Eliminate a bunch of this magic.
-          "Cannot exceed64 characters"
-        )
-      }
-    end
-
-    # TODO: test the other rules
-  end
-end

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

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

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