foobara 0.5.10 → 0.6.2

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

@@ -1,138 +0,0 @@
-RSpec.describe Foobara::BuiltinTypes::Duck::SupportedCasters::AllowNil do
-  let(:type_declaration) do
-    :integer
-  end
-
-  let(:type) do
-    Foobara::GlobalDomain.foobara_type_from_declaration(*Foobara::Util.array(type_declaration))
-  end
-
-  describe ".instance" do
-    it "has false declaration data" do
-      expect(described_class.instance.declaration_data).to be(false)
-    end
-  end
-
-  context "when not set" do
-    it "does not allow nil" do
-      outcome = type.process_value(5)
-      expect(outcome).to be_success
-      expect(outcome.result).to eq(5)
-
-      outcome = type.process_value(nil)
-      expect(outcome).to_not be_success
-      expect(outcome.error_keys).to eq(["data.cannot_cast"])
-    end
-  end
-
-  context "when set to true" do
-    let(:type_declaration) do
-      [:integer, { allow_nil: true }]
-    end
-
-    it "does allow nil" do
-      outcome = type.process_value(5)
-      expect(outcome).to be_success
-      expect(outcome.result).to eq(5)
-
-      outcome = type.process_value(nil)
-      expect(outcome).to be_success
-      expect(outcome.result).to be_nil
-    end
-  end
-
-  context "with entire attributes that allow_nil" do
-    let(:type_declaration) do
-      {
-        type: :attributes,
-        element_type_declarations: {
-          foo: :integer
-        },
-        required: :foo,
-        allow_nil: true
-      }
-    end
-
-    context "when not nil" do
-      it "works as usual" do
-        outcome = type.process_value(foo: 5)
-
-        expect(outcome).to be_success
-        expect(outcome.result).to eq(foo: 5)
-      end
-    end
-
-    context "when nil" do
-      it "returns nil" do
-        outcome = type.process_value(nil)
-
-        expect(outcome).to be_success
-        expect(outcome.result).to be_nil
-      end
-    end
-  end
-
-  context "with attribute that is allow_nil" do
-    let(:type_declaration) do
-      proc do
-        default :integer
-        implicit_true :integer, :allow_nil
-        explicit_true :integer, allow_nil: true
-        explicit_false :integer, allow_nil: false
-      end
-    end
-
-    it "allows nil the implicit true and the explicit true" do
-      outcome = type.process_value(
-        default: nil,
-        implicit_true: nil,
-        explicit_true: nil,
-        explicit_false: nil
-      )
-
-      expect(outcome).to_not be_success
-      expect(outcome.error_keys).to eq(
-        [
-          "data.default.cannot_cast",
-          "data.explicit_false.cannot_cast"
-        ]
-      )
-
-      outcome = type.process_value(
-        default: 5,
-        implicit_true: nil,
-        explicit_true: nil,
-        explicit_false: 5
-      )
-
-      expect(outcome).to be_success
-      expect(outcome.result).to eq(
-        default: 5,
-        implicit_true: nil,
-        explicit_true: nil,
-        explicit_false: 5
-      )
-    end
-
-    context "when registering it" do
-      before do
-        # TODO: we need a helper to simplify this...
-        Foobara::Namespace::NamespaceHelpers.foobara_namespace!(type)
-
-        type.type_symbol = :some_type
-
-        expect {
-          Foobara::GlobalDomain.foobara_register(type)
-        }.to change { Foobara::GlobalDomain.foobara_registered?(type) }.from(false).to(true)
-      end
-
-      it "shows up in the manifest" do
-        manifest = Foobara.manifest
-
-        expect(
-          manifest[:type][:some_type][:declaration_data][:element_type_declarations][:implicit_true][:allow_nil]
-        ).to be(true)
-      end
-    end
-  end
-end

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

@@ -1,140 +0,0 @@
-RSpec.describe ":array" do
-  let(:type) { Foobara::BuiltinTypes[:array] }
-
-  it "is a builtin type" do
-    expect(Foobara::BuiltinTypes.builtin?(type)).to be(true)
-  end
-
-  it "is a builtin reference" do
-    expect(Foobara::BuiltinTypes.builtin_reference?("array")).to be(true)
-  end
-
-  describe "#process_value!" do
-    subject { type.process_value!(value) }
-
-    context "when array" do
-      let(:value) { [1, 2] }
-
-      it { is_expected.to eq([1, 2]) }
-    end
-
-    context "when hash" do
-      let(:value) { { a: 1, b: 2 } }
-
-      it { is_expected.to eq([[:a, 1], [:b, 2]]) }
-    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 Array, or respond to :to_a/
-        )
-      }
-    end
-  end
-
-  describe "#cast!" do
-    subject { type.cast!(value) }
-
-    context "when not castable" do
-      let(:value) { Object.new }
-
-      it {
-        is_expected_to_raise(
-          Foobara::Value::Processor::Casting::CannotCastError, /Expected it to be a Array, or respond to :to_a/
-        )
-      }
-    end
-  end
-
-  context "when using an element_type_declaration" do
-    let(:type) { Foobara::Domain.current.foobara_type_from_declaration([:integer]) }
-
-    context "when element types match the element_type_declaration" do
-      let(:array) { [1, 2, 3, 4] }
-
-      it "can process it" do
-        expect(type.process_value!(array)).to eq(array)
-      end
-    end
-
-    context "when element types do not match the element_type_declaration" do
-      let(:array) { [1, 2, { not: :valid }, 4] }
-
-      it "can process it" do
-        outcome = type.process_value(array)
-        expect(outcome).to_not be_success
-
-        expect(outcome.errors_hash).to eq(
-          "data.2.cannot_cast" => {
-            key: "data.2.cannot_cast",
-            path: [2],
-            runtime_path: [],
-            is_fatal: true,
-            category: :data,
-            symbol: :cannot_cast,
-            message: "At 2: 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 } }
-          }
-        )
-
-        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.#.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError
-        )
-      end
-    end
-  end
-
-  context "when using a type declaration" do
-    let(:type) do
-      Foobara::Domain.current.foobara_type_from_declaration(type_declaration)
-    end
-
-    context "when extending with an array literal and a description" do
-      let(:type_declaration) do
-        { type: [:string], description: "An array of strings", sensitive: true, sensitive_exposed: true }
-      end
-
-      it "has the description and is an array type as expected" do
-        expect(type.extends?(:array)).to be(true)
-        expect(type.description).to eq("An array of strings")
-        expect(type).to be_sensitive
-        expect(type).to be_sensitive_exposed
-        expect(type.process_value!([:foo, 1])).to eq(["foo", "1"])
-      end
-    end
-
-    context "when element type declaration is a Type" do
-      let(:type_declaration) do
-        { type: :array, element_type_declaration: Foobara::BuiltinTypes[:integer] }
-      end
-
-      it "creates the expected type" do
-        s = type.process_value!(["1", "2"])
-        expect(s).to eq([1, 2])
-
-        outcome = type.process_value(["asdf"])
-        expect(outcome).to_not be_success
-      end
-    end
-
-    context "when using array sugar of a Type" do
-      let(:type_declaration) do
-        [Foobara::BuiltinTypes[:integer]]
-      end
-
-      it "creates the expected type" do
-        s = type.process_value!(["1", "2"])
-        expect(s).to eq([1, 2])
-
-        outcome = type.process_value(["asdf"])
-        expect(outcome).to_not be_success
-      end
-    end
-  end
-end

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

@@ -1,228 +0,0 @@
-RSpec.describe ":associative_array" do
-  let(:type) { Foobara::BuiltinTypes[:associative_array] }
-
-  describe "#process_value!" do
-    subject { type.process_value!(value) }
-
-    context "when array of pairs" do
-      let(:value) { [[:a, 1], [:b, 2]] }
-
-      it { is_expected.to eq(a: 1, b: 2) }
-    end
-
-    context "when hash" do
-      let(:value) { { key1 => 1, key2 => 2 } }
-      let(:key1) { Object.new }
-      let(:key2) { Object.new }
-
-      it { is_expected.to eq(key1 => 1, key2 => 2) }
-    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 Hash, or be a an array of pairs/)
-      }
-    end
-
-    context "when there's a key_type_declaration" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(
-          :associative_array,
-          key_type_declaration: :boolean
-        )
-      end
-
-      describe "#types_depended_on" do
-        it "includes the key type" do
-          expect(type.types_depended_on.map(&:type_symbol)).to include(:boolean)
-        end
-
-        context "when working with stringified values" do
-          let(:type) do
-            Foobara::Domain.current.foobara_type_from_declaration(
-              "type" => "associative_array",
-              "key_type_declaration" => "boolean"
-            )
-          end
-
-          it "includes the key type" do
-            expect(type.types_depended_on.map(&:type_symbol)).to include(:boolean)
-            expect(type.declaration_data).to eq(type: :associative_array, key_type_declaration: :boolean)
-          end
-        end
-
-        context "when key_type_declaration is a Type" do
-          let(:type) do
-            Foobara::Domain.current.foobara_type_from_declaration(
-              :associative_array,
-              key_type_declaration: Foobara::BuiltinTypes[:boolean]
-            )
-          end
-
-          it "includes the key type" do
-            expect(type.types_depended_on.map(&:type_symbol)).to include(:boolean)
-          end
-        end
-
-        context "when it's a deep-duped declaration" do
-          let(:type) do
-            declaration_data = {
-              type: :associative_array,
-              key_type_declaration: { type: :boolean }
-            }
-
-            declaration = Foobara::TypeDeclaration.new(declaration_data)
-            handler = Foobara::Domain.current.foobara_type_builder.type_declaration_handler_for(declaration)
-
-            declaration = Foobara::TypeDeclaration.new(declaration_data)
-            declaration.is_deep_duped = true
-
-            handler.process_value!(declaration)
-          end
-
-          it "includes the key type" do
-            expect(type.types_depended_on.map(&:type_symbol)).to include(:boolean)
-          end
-        end
-      end
-
-      describe "#possible_errors" do
-        it "contains expected possible errors" do
-          expect(type.possible_errors.to_h { |p| [p.key.to_sym, p.error_class] }).to eq(
-            "data.#.key.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
-            "data.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError
-          )
-        end
-      end
-
-      context "when keys adhere to type" do
-        let(:value) do
-          { y: 1, "FaLsE" => 2 }
-        end
-
-        it { is_expected.to eq(true => 1, false => 2) }
-      end
-
-      context "when keys do not adhere" do
-        let(:outcome) { type.process_value(value) }
-        let(:errors) { outcome.errors }
-
-        let(:value) { { a: 1, b: 2 } }
-
-        it "is not success" do
-          expect(outcome).to_not be_success
-
-          expect(errors.size).to eq(2)
-          expect(errors.map(&:path)).to contain_exactly([0, :key], [1, :key])
-          expect(errors).to all be_a(Foobara::Value::Processor::Casting::CannotCastError)
-        end
-      end
-    end
-
-    context "when there's a value_type_declaration" do
-      let(:type) do
-        Foobara::Domain.current.foobara_type_from_declaration(
-          :associative_array,
-          value_type_declaration: :boolean
-        )
-      end
-
-      describe "#possible_errors" do
-        it "contains expected possible errors" do
-          expect(type.possible_errors.to_h { |possible_error|
-                   [possible_error.key.to_sym, possible_error.error_class]
-                 }).to eq(
-                   "data.#.value.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
-                   "data.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError
-                 )
-        end
-      end
-
-      context "when values adhere to type" do
-        let(:value) do
-          { a: 1, b: "FalsE" }
-        end
-
-        it { is_expected.to eq(a: true, b: false) }
-      end
-
-      context "when values do not adhere" do
-        let(:outcome) { type.process_value(value) }
-        let(:errors) { outcome.errors }
-
-        let(:value) { { a: :foo, b: 2 } }
-
-        it "is not success" do
-          expect(outcome).to_not be_success
-
-          expect(errors.size).to eq(2)
-          expect(errors.map(&:path)).to contain_exactly([0, :value], [1, :value])
-          expect(errors).to all be_a(Foobara::Value::Processor::Casting::CannotCastError)
-        end
-      end
-
-      context "when working with stringified values" do
-        let(:type) do
-          Foobara::Domain.current.foobara_type_from_declaration(
-            "type" => "associative_array",
-            "value_type_declaration" => "boolean"
-          )
-        end
-
-        it "includes the key type" do
-          expect(type.types_depended_on.map(&:type_symbol)).to include(:boolean)
-        end
-      end
-
-      context "when value_type_declaration is a Type" do
-        let(:type) do
-          Foobara::Domain.current.foobara_type_from_declaration(
-            :associative_array,
-            value_type_declaration: Foobara::BuiltinTypes[:boolean]
-          )
-        end
-
-        it "includes the key type" do
-          expect(type.types_depended_on.map(&:type_symbol)).to include(:boolean)
-        end
-      end
-
-      context "when it's a deep-duped declaration" do
-        let(:type) do
-          declaration_data = {
-            type: :associative_array,
-            value_type_declaration: { type: :boolean }
-          }
-
-          declaration = Foobara::TypeDeclaration.new(declaration_data)
-          handler = Foobara::Domain.current.foobara_type_builder.type_declaration_handler_for(declaration)
-
-          declaration = Foobara::TypeDeclaration.new(declaration_data)
-          declaration.is_deep_duped = true
-
-          handler.process_value!(declaration)
-        end
-
-        it "includes the key type" do
-          expect(type.types_depended_on.map(&:type_symbol)).to include(:boolean)
-        end
-      end
-    end
-  end
-
-  describe "#cast!" do
-    subject { type.cast!(value) }
-
-    context "when not castable" do
-      let(:value) { Object.new }
-
-      it {
-        is_expected_to_raise(Foobara::Value::Processor::Casting::CannotCastError,
-                             /Expected it to be a Hash, or be a an array of pairs\z/)
-      }
-    end
-  end
-end