foobara 0.3.0 → 0.4.1

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

@@ -0,0 +1,42 @@
+RSpec.describe ":big_decimal" do
+  let(:type) { Foobara::BuiltinTypes[:big_decimal] }
+
+  describe "#process!" do
+    subject { type.process_value!(value) }
+
+    def is_expected_to_be_big_decimal_for(i_or_s)
+      expect(subject).to be_a(BigDecimal)
+      expect(subject).to eq(BigDecimal(i_or_s))
+    end
+
+    context "when ::BigDecimal" do
+      let(:value) { BigDecimal(10) }
+
+      it { is_expected.to be(value) }
+    end
+
+    context "when ::Integer" do
+      let(:value) { 10 }
+
+      it { is_expected_to_be_big_decimal_for(10) }
+    end
+
+    context "when '1.3'" do
+      let(:value) { "1.3" }
+
+      it { is_expected_to_be_big_decimal_for("1.3") }
+    end
+
+    context "when '-1.3E-5'" do
+      let(:value) { "-1.3E-5" }
+
+      it { is_expected_to_be_big_decimal_for("-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/boolean_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe ":boolean" do
+  let(:type) { Foobara::BuiltinTypes[:boolean] }
+
+  describe "#process!" do
+    subject { type.process_value!(value) }
+
+    context "when true" do
+      let(:value) { true }
+
+      it { is_expected.to be(value) }
+    end
+
+    context "when false" do
+      let(:value) { false }
+
+      it { is_expected.to be(value) }
+    end
+
+    context "when 'T'" do
+      let(:value) { "T" }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "when 0" do
+      let(:value) { 0 }
+
+      it { is_expected.to be(false) }
+    end
+
+    context "when 'n'" do
+      let(:value) { "n" }
+
+      it { is_expected.to be(false) }
+    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/class_type_desugarizer_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe "ClassTypeDesugarizer" do
+  context "when using Class as a type" do
+    let(:some_class) do
+      stub_class("SomeClass")
+    end
+
+    let(:type) do
+      Foobara::Domain.current.foobara_type_from_declaration(type: some_class, allow_nil: true)
+    end
+
+    it "desugarizes to :duck with :instance_of" do
+      expect(type.declaration_data).to eq(type: :duck, instance_of: "SomeClass", allow_nil: true)
+      expect(type.process_value!(some_class.new)).to be_a(some_class)
+      expect(type.process_value!(nil)).to be_nil
+    end
+  end
+end

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

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

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

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

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