foobara 0.3.0 → 0.4.1

data/projects/{types → typesystem/projects/types}/src/type.rb

@@ -135,41 +135,6 @@ module Foobara
         end
       end
 
-      def apply_all_processors_needing_type!
-        each_processor_class_requiring_type do |processor_class|
-          # TODO: is this a smell?
-          processor = processor_class.new(self)
-
-          category = case processor
-                     when Value::Caster
-                       casters
-                     when Value::Validator
-                       # :nocov:
-                       validators
-                       # :nocov:
-                     when Value::Transformer
-                       # :nocov:
-                       transformers
-                       # :nocov:
-                     when Types::ElementProcessor
-                       # :nocov:
-                       element_processors
-                       # :nocov:
-                     else
-                       # TODO: add validator that these are all fine so we don't have to bother here...
-                       # :nocov:
-                       raise "Not sure where to put #{processor}"
-                       # :nocov:
-                     end
-
-          symbol = processor.symbol
-          category.delete_if { |p| p.symbol == symbol }
-
-          category << processor
-          clear_caches
-        end
-      end
-
       def clear_caches
         [
           :@value_validator,
@@ -218,34 +183,6 @@ module Foobara
         end
       end
 
-      def validate_processors!
-        all = [casters, transformers, validators, element_processors]
-
-        all.each do |processor_group|
-          processor_group.each.with_index do |processor, index|
-            if processor.requires_parent_declaration_data?
-              processor_group[index] = processor.dup_processor(parent_declaration_data: declaration_data)
-            end
-          end
-
-          processor_group.group_by(&:symbol).each_pair do |symbol, members|
-            if members.size > 1
-              if members.map { |m| m.class.name }.uniq.size == members.size
-                members[1..].each do |member|
-                  processor_group.delete(member)
-                end
-              else
-                # :nocov:
-                raise "Type #{name} has multiple processors with symbol #{symbol}"
-                # :nocov:
-              end
-            end
-          end
-        end
-
-        clear_caches
-      end
-
       def target_class
         if target_classes.empty?
           # :nocov:
@@ -421,7 +358,9 @@ module Foobara
         !value_caster.needs_cast?(value) || value_caster.can_cast?(value)
       end
 
-      foobara_delegate :needs_cast?, to: :value_caster
+      def needs_cast?(value)
+        value_caster.needs_cast?(value)
+      end
 
       def cast(value)
         value_caster.process_value(value)
@@ -573,6 +512,75 @@ module Foobara
         base_type
       end
 
+      def registered?
+        !!type_symbol
+      end
+
+      private
+
+      def apply_all_processors_needing_type!
+        each_processor_class_requiring_type do |processor_class|
+          # TODO: is this a smell?
+          processor = processor_class.new(self)
+
+          category = case processor
+                     when Value::Caster
+                       casters
+                     when Value::Validator
+                       # :nocov:
+                       validators
+                       # :nocov:
+                     when Value::Transformer
+                       # :nocov:
+                       transformers
+                       # :nocov:
+                     when Types::ElementProcessor
+                       # :nocov:
+                       element_processors
+                       # :nocov:
+                     else
+                       # TODO: add validator that these are all fine so we don't have to bother here...
+                       # :nocov:
+                       raise "Not sure where to put #{processor}"
+                       # :nocov:
+                     end
+
+          symbol = processor.symbol
+          category.delete_if { |p| p.symbol == symbol }
+
+          category << processor
+          clear_caches
+        end
+      end
+
+      def validate_processors!
+        all = [casters, transformers, validators, element_processors]
+
+        all.each do |processor_group|
+          processor_group.each.with_index do |processor, index|
+            if processor.requires_parent_declaration_data?
+              processor_group[index] = processor.dup_processor(parent_declaration_data: declaration_data)
+            end
+          end
+
+          processor_group.group_by(&:symbol).each_pair do |symbol, members|
+            if members.size > 1
+              if members.map { |m| m.class.name }.uniq.size == members.size
+                members[1..].each do |member|
+                  processor_group.delete(member)
+                end
+              else
+                # :nocov:
+                raise "Type #{name} has multiple processors with symbol #{symbol}"
+                # :nocov:
+              end
+            end
+          end
+        end
+
+        clear_caches
+      end
+
       def supported_processor_manifest
         to_include = TypeDeclarations.foobara_manifest_context_to_include
 
@@ -671,10 +679,6 @@ module Foobara
           validator_classes: validator_classes_manifest.sort
         )
       end
-
-      def registered?
-        !!type_symbol
-      end
     end
   end
 

data/projects/typesystem/projects/value/lib/foobara/value.rb

@@ -0,0 +1,12 @@
+require "foobara/domain"
+require "foobara/common"
+
+module Foobara
+  module Value
+    foobara_domain!
+  end
+
+  require_relative "../../src/processor"
+end
+
+Foobara.project("value", project_path: "#{__dir__}/../..")

data/projects/{value → typesystem/projects/value}/src/processor.rb

@@ -177,12 +177,25 @@ module Foobara
         self.class.processor_name
       end
 
-      foobara_delegate :error_class,
-                       :error_classes,
-                       :symbol,
-                       :requires_declaration_data?,
-                       :requires_parent_declaration_data?,
-                       to: :class
+      def error_class
+        self.class.error_class
+      end
+
+      def error_classes
+        self.class.error_classes
+      end
+
+      def symbol
+        self.class.symbol
+      end
+
+      def requires_declaration_data?
+        self.class.requires_declaration_data?
+      end
+
+      def requires_parent_declaration_data?
+        self.class.requires_parent_declaration_data?
+      end
 
       # Whoa, forgot this existed. Shouldn't we use this more?
       def runner(value)

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

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

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