foobara 0.3.0 → 0.4.1

data/projects/typesystem/spec/types/type_spec.rb

@@ -0,0 +1,102 @@
+RSpec.describe Foobara::Types do
+  let(:type) { Foobara::Domain.current.foobara_type_from_declaration(type_declaration) }
+
+  context "when created from scratch" do
+    let(:type) do
+      Foobara::Types::Type.new(
+        "whatever",
+        base_type: nil,
+        target_classes: [Object]
+      )
+    end
+
+    it "has no scoped path set" do
+      expect(type).to_not be_scoped_path_set
+    end
+  end
+
+  context "when :attributes" do
+    let(:type_declaration) { { foo: :duck } }
+
+    describe "#cast_from" do
+      let(:outcome) { type.process_value(hash) }
+      let(:result) { outcome.result }
+      let(:errors) { outcome.errors }
+
+      context "when hash has symbolic keys" do
+        let(:hash) { { foo: "bar" } }
+
+        it "is the hash" do
+          expect(outcome).to be_success
+          expect(result).to eq(hash)
+        end
+      end
+
+      context "when hash has symbolizable keys" do
+        let(:hash) { { "foo" => "bar" } }
+
+        it "is the hash with symbolized keys" do
+          expect(outcome).to be_success
+          expect(result).to eq(foo: "bar")
+        end
+      end
+
+      context "when hash has non-symbolizable keys" do
+        let(:hash) { { 10 => "bar" } }
+
+        it "is the hash" do
+          expect(outcome).to_not be_success
+          expect(errors.first.symbol).to eq(:cannot_cast)
+        end
+      end
+    end
+
+    describe "#extends_directly?" do
+      context "when a symbol" do
+        it "is true for its parent symbol" do
+          expect(type.extends_directly?(:attributes)).to be(true)
+        end
+      end
+    end
+  end
+
+  describe "#primitive?" do
+    subject { type.primitive? }
+
+    let(:type) { Foobara::Domain.current.foobara_type_from_declaration(type_declaration) }
+
+    context "when primitive" do
+      let(:type_declaration) { :integer }
+
+      it { is_expected.to be true }
+    end
+
+    context "when derived" do
+      let(:type_declaration) do
+        { type: :integer, description: "an integer!" }
+      end
+
+      it { is_expected.to be false }
+    end
+  end
+
+  describe "#derived?" do
+    subject { type.derived? }
+
+    let(:type) { Foobara::Domain.current.foobara_type_from_declaration(type_declaration) }
+
+    context "when primitive" do
+      let(:type_declaration) { :integer }
+
+      it { is_expected.to be false }
+    end
+
+    context "when derived" do
+      let(:type_declaration) do
+        { type: :integer, description: "an integer!" }
+      end
+
+      it { is_expected.to be true }
+    end
+  end
+end

data/projects/typesystem/spec/value/caster_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Foobara::Value::Caster do
+  let(:caster) { described_class.instance }
+
+  describe ".create" do
+    let(:caster) do
+      described_class.create(
+        cast: ->(_whatever) { 1000 },
+        name: "Always1000",
+        applies_message: "be anything"
+      )
+    end
+
+    after do
+      described_class.send(:remove_const, :Always1000)
+    end
+
+    it "creates caster instance with desired behavior" do
+      expect(caster.transform(5)).to eq(1000)
+      expect(caster.name).to eq("Foobara::Value::Caster::Always1000")
+      expect(caster.applies_message).to eq("be anything")
+    end
+  end
+end

data/projects/typesystem/spec/value/processor/runner_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe Foobara::Value::Processor::Runner do
+  let(:processor_class) {
+    stub_class :Doubler, Foobara::Value::Transformer do
+      attr_accessor :calls
+
+      def initialize(...)
+        super
+        self.calls = 0
+      end
+
+      def transform(value)
+        self.calls += 1
+        value * 2
+      end
+    end.tap do
+      stub_class("Doubler::Error", Foobara::Value::DataError)
+    end
+  }
+
+  let(:processor) { processor_class.instance }
+
+  let(:runner) { processor.runner(value) }
+  let(:value) { 5 }
+
+  describe "calling a runner method twice" do
+    it "memoizes" do
+      expect(processor.calls).to eq(0)
+      expect(runner.transform).to eq(10)
+      expect(processor.calls).to eq(1)
+      expect(runner.transform).to eq(10)
+      expect(processor.calls).to eq(1)
+    end
+  end
+end

data/projects/typesystem/spec/value/processor/selection_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe Foobara::Value::Processor::Selection do
+  describe "#processor_for!" do
+    subject { selection.processor_for!(value) }
+
+    let(:processor_a) do
+      stub_class "ProcessorA", Foobara::Value::Processor do
+        def applicable?(value)
+          value == :a
+        end
+      end.instance
+    end
+
+    let(:processor_b) do
+      stub_class "ProcessorB", Foobara::Value::Processor do
+        class << self
+          def name
+            "ProcessorB"
+          end
+        end
+        def applicable?(value)
+          value == :b
+        end
+      end.instance
+    end
+
+    let(:processors) { [processor_a, processor_b] }
+
+    let(:selection) do
+      described_class.new(processors:, enforce_unique:)
+    end
+    let(:enforce_unique) { false }
+
+    context "when wanting nil when no processor matches" do
+      let(:error_if_none_applicable) { false }
+      let(:selection) do
+        described_class.new(processors:, enforce_unique:, error_if_none_applicable:)
+      end
+
+      context "when it does not match a processor" do
+        let(:value) { :c }
+
+        it { is_expected.to be_nil }
+      end
+    end
+
+    context "when unique enforced" do
+      let(:enforce_unique) { true }
+
+      context "when it matches multiple processors" do
+        let(:processors) { [processor_a, processor_a] }
+        let(:value) { :a }
+
+        it { is_expected_to_raise(described_class::MoreThanOneApplicableProcessorError) }
+      end
+    end
+
+    context "when unique not enforced" do
+      context "when it matches a processor" do
+        let(:value) { :a }
+
+        it { is_expected.to be(processor_a) }
+      end
+
+      context "when it does not match a processor" do
+        let(:value) { :c }
+
+        it { is_expected_to_raise(described_class::NoApplicableProcessorError) }
+      end
+    end
+  end
+end

data/projects/typesystem/spec/value/processor_spec.rb

@@ -0,0 +1,76 @@
+RSpec.describe Foobara::Value::Processor do
+  let(:processor_class) {
+    stub_class "SomeProcessor", described_class do
+      def process_value(value)
+        if value == 123
+          Foobara::Outcome.error(build_error(symbol: :foo, message: "some error", context: {}))
+        else
+          Foobara::Outcome.success(value)
+        end
+      end
+    end.tap do
+      stub_class "SomeProcessor::Error", Foobara::Value::DataError
+    end
+  }
+
+  let(:processor) { processor_class.new(foo: :bar) }
+
+  describe "#process!" do
+    context "when is an error" do
+      it "raises" do
+        expect {
+          processor.process_value!(123)
+        }.to raise_error(processor_class::Error)
+      end
+    end
+  end
+
+  describe "#process_outcome!" do
+    context "when is an error" do
+      it "raises" do
+        expect {
+          processor.process_outcome!(Foobara::Outcome.success(123))
+        }.to raise_error(processor_class::Error)
+      end
+    end
+
+    context "when is not an error" do
+      it "gives the result" do
+        expect(processor.process_outcome!(Foobara::Outcome.success(10))).to eq(10)
+      end
+    end
+  end
+
+  describe "#dup_processor" do
+    context "when overriding declaration data" do
+      it "dups the processor" do
+        duped_processor = processor.dup_processor(declaration_data: { bar: "baz" })
+
+        expect(processor.declaration_data).to eq(foo: :bar)
+        expect(duped_processor.declaration_data).to eq(bar: "baz")
+      end
+    end
+  end
+
+  describe ".new_with_agnostic_args" do
+    context "when requires declaration data" do
+      let(:processor_class) do
+        stub_class "SomeProcessor", described_class do
+          class << self
+            def requires_declaration_data?
+              true
+            end
+          end
+        end
+      end
+
+      context "when no declaration data provided" do
+        let(:processor) { processor_class.new_with_agnostic_args }
+
+        it "has true as its declaration data" do
+          expect(processor.declaration_data).to be true
+        end
+      end
+    end
+  end
+end

data/projects/typesystem/spec/value/transformer_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Foobara::Value::Transformer do
+  let(:transformer) { described_class.instance }
+
+  describe ".create" do
+    let(:transformer) do
+      stub_module "SomeModule"
+
+      described_class.create(
+        transform: ->(_whatever) { 1000 },
+        name: "SomeModule::Always1000",
+        priority: 40
+      )
+    end
+
+    it "creates transformer instance with desired behavior" do
+      expect(transformer.transform(5)).to eq(1000)
+      expect(transformer.name).to eq("SomeModule::Always1000")
+      expect(transformer.priority).to eq(40)
+    end
+  end
+
+  describe "#possible_errors" do
+    it "is always empty" do
+      expect(transformer.possible_errors).to eq([])
+    end
+  end
+end

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.3.0".freeze
+    VERSION = "0.4.1".freeze
     MINIMUM_RUBY_VERSION = ">= 3.4.0".freeze
   end
 end