functional-light-service 6.1.0 → 6.3.0

data/spec/lib/edge_cases_spec.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-require 'functional-light-service/functional/maybe'
-
-# Copertura dei path d'errore e delle API minori emersi dall'audit
-describe "edge cases and error paths" do
-  include FunctionalLightService::Prelude::Result
-  include FunctionalLightService::Prelude::Option
-
-  describe FunctionalLightService::Context do
-    it "#add_to_context merges values" do
-      ctx = FunctionalLightService::Context.make(:a => 1)
-      ctx.add_to_context(:b => 2)
-
-      expect(ctx[:b]).to eq(2)
-    end
-  end
-
-  describe FunctionalLightService::Context::KeyVerifier do
-    it "the base verifier requires throw_error_predicate to be overridden" do
-      ctx = FunctionalLightService::Context.make
-      verifier = described_class.new(ctx, nil)
-
-      expect { verifier.throw_error_predicate([]) }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe "Object monkey patch (opt-in via functional/maybe)" do
-    it "defines null? and some? on every object" do
-      expect("anything".null?).to be(false)
-      expect("anything".some?).to be(true)
-    end
-  end
-
-  describe Null do
-    it "class-level unknown messages return the singleton" do
-      expect(Null.anything_at_all).to eq(Null.instance)
-    end
-
-    it "class-level respond_to? is permissive" do
-      expect(Null.respond_to?(:anything_at_all)).to be(true)
-    end
-
-    it "compares equal to another Null" do
-      expect(Null.instance == Null.instance).to be(true) # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
-      expect(Null.instance == "not null").to be(false)
-    end
-
-    it "a mimic only responds to the mimicked interface" do
-      klass = Class.new { def foo; end }
-      mimic = Null.mimic(klass)
-
-      expect(mimic.respond_to?(:foo)).to be(true)
-      expect(mimic.respond_to?(:bar)).to be(false)
-      expect { mimic.bar }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe "enum error paths" do
-    it "raises when a variant is defined twice" do
-      expect do
-        FunctionalLightService.enum do
-          Dup()
-          Dup()
-        end
-      end.to raise_error(ArgumentError, /already defined/)
-    end
-
-    it "the enum builder responds to any variant name" do
-      builder = FunctionalLightService::EnumBuilder.new(Class.new)
-
-      expect(builder.respond_to?(:AnyVariantName)).to be(true)
-    end
-
-    it "raises MatchError when the match is not exhaustive" do
-      expect do
-        Some(1).match do
-          Some() { |s| s }
-        end
-      end.to raise_error(FunctionalLightService::Enum::MatchError, /non-exhaustive/)
-    end
-
-    it "raises MatchError when the block arity does not match the variant" do
-      expect do
-        Some(1).match do
-          Some() { |a, b| [a, b] }
-          None() { nil }
-        end
-      end.to raise_error(FunctionalLightService::Enum::MatchError, /must match/)
-    end
-
-    it "raises MatchError when no guard matches" do
-      expect do
-        Some(1).match do
-          Some(where { s > 100 }) { |s| s }
-          None() { nil }
-        end
-      end.to raise_error(FunctionalLightService::Enum::MatchError, /No match could be made/)
-    end
-
-    it "rejects unnamed/rest block parameters" do
-      # su Ruby 3.1 |*| appare come [[:rest]] (ramo "Unnamed param"),
-      # da Ruby 3.2 come [[:rest, :*]] (ramo "Only :req & :opt")
-      expect do
-        Some(1).match do
-          Some() { |*| nil }
-          None() { nil }
-        end
-      end.to raise_error(ArgumentError, /Unnamed param|Only :req & :opt/)
-    end
-
-    it "rejects keyword block parameters" do
-      expect do
-        Some(1).match do
-          Some() { |**opts| opts }
-          None() { nil }
-        end
-      end.to raise_error(ArgumentError, /Only :req & :opt params allowed/)
-    end
-
-    it "None deconstructs to an empty hash and array" do
-      none = FunctionalLightService::Option::None.new
-
-      expect(none.deconstruct).to eq([])
-      expect(none.deconstruct_keys(nil)).to eq({})
-    end
-  end
-
-  describe "Option minor APIs" do
-    it "#value_to_a returns the raw value" do
-      expect(Some(1).value_to_a).to eq(1)
-      expect(FunctionalLightService::Option::None.new.value_to_a).to be_nil
-    end
-
-    it "Prelude None() builds the shared None" do
-      expect(None().none?).to be(true)
-    end
-
-    it "Prelude Option() returns the Option enum" do
-      expect(Option()).to eq(FunctionalLightService::Option)
-    end
-  end
-
-  describe "Result minor APIs" do
-    it "#+ raises NotMonadError for non-Result operands" do
-      expect { Success(1) + "not a result" } # rubocop:disable Style/StringConcatenation
-        .to raise_error(FunctionalLightService::Monad::NotMonadError)
-    end
-
-    it "Prelude try! wraps exceptions in Failure" do
-      result = try! { raise "boom" }
-
-      expect(result).to be_failure
-      expect(result.value).to be_a(RuntimeError)
-    end
-  end
-end

data/spec/lib/enum_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-describe FunctionalLightService::Enum do
-  include FunctionalLightService
-
-  it "can't use value" do
-    expect do
-      InvalidEnum = FunctionalLightService.enum do
-        Unary(:value)
-      end
-    end.to raise_error ArgumentError
-  end
-
-  context "Nullary, Unary, Binary" do
-    MyEnym = FunctionalLightService.enum do
-      Nullary()
-      Unary(:a)
-      Binary(:a, :b)
-    end
-
-    it "can't instantiate parent" do
-      expect { MyEnym.new }.to \
-        raise_error NoMethodError, /private method [`']new'/
-    end
-
-    it "Nullary" do
-      n = MyEnym.Nullary
-
-      expect(n).to be_a MyEnym
-      expect(n).to be_a MyEnym::Nullary
-      expect(n.name).to eq "Nullary"
-      expect { n.value }.to raise_error NoMethodError
-      expect(n.inspect).to eq "Nullary"
-      expect(n.to_s).to eq ""
-      # rubocop:disable Lint/EmptyBlock
-      expect(n.fmap {}).to eq n
-      # rubocop:enable Lint/EmptyBlock
-    end
-
-    it "Unary" do
-      u = MyEnym::Unary(1)
-
-      expect(u).to be_a MyEnym
-      expect(u).to be_a MyEnym::Unary
-      expect(u.name).to eq "Unary"
-      expect(u.a).to eq 1
-      expect(u.value).to eq 1
-      expect(u.inspect).to eq "Unary(1)"
-      expect(u.to_s).to eq "1"
-    end
-
-    it "Binary" do
-      # hash
-      b = MyEnym::Binary(:a => 1, :b => 2)
-      expect(b).to be_a MyEnym
-      expect(b).to be_a MyEnym::Binary
-      expect(b.name).to eq "Binary"
-      expect(b.inspect).to eq "Binary(a: 1, b: 2)"
-
-      expect(b.a).to eq 1
-      expect(b.b).to eq 2
-      expect(b.value).to eq(:a => 1, :b => 2)
-
-      # values only
-      b = MyEnym::Binary(1, 2)
-      expect(b.value).to eq(:a => 1, :b => 2)
-
-      # other names are ok
-      b = MyEnym::Binary(:c => 1, :d => 2)
-      expect(b.value).to eq(:a => 1, :b => 2)
-
-      expect { MyEnym::Binary(1) }.to raise_error ArgumentError
-    end
-
-    it "generated enum" do
-      expect(MyEnym.variants.sort).to eq %i[Unary Binary Nullary].sort
-      expect(MyEnym.constants.sort.inspect).to eq %i[Matcher Unary Binary Nullary].sort.to_s
-
-      b = MyEnym::Binary(:a => 1, :b => 2)
-
-      res =
-        MyEnym.match(b) do
-          Nullary() { 0 }
-          Unary() { |a| a }
-          Binary() { |x, y| [x, y] }
-        end
-
-      expect(res).to eq [1, 2]
-
-      res =
-        b.match do
-          Nullary() { 0 }
-          Unary() { |a| a }
-          Binary() { |x, y| [x, y] }
-        end
-
-      expect(res).to eq [1, 2]
-
-      expect do
-        b.match do
-          Nullary # Nullary is treated as a constant
-        end
-      end.to raise_error(NameError)
-
-      expect do
-        b.match do
-          Nullary()
-          Unary()
-          Binary()
-        end
-      end.to raise_error ArgumentError, "No block given to `Nullary`"
-    end
-  end
-end

data/spec/lib/native_pattern_matching_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe "native Ruby pattern matching (case/in) support" do
-  include FunctionalLightService::Prelude::Result
-  include FunctionalLightService::Prelude::Option
-
-  Result = FunctionalLightService::Result
-  Option = FunctionalLightService::Option
-
-  it "deconstructs Success/Failure positionally" do
-    matched =
-      case Success(42)
-      in Result::Success[value] then "success: #{value}"
-      in Result::Failure[error] then "failure: #{error}"
-      end
-
-    expect(matched).to eq("success: 42")
-  end
-
-  it "deconstructs Failure positionally" do
-    matched =
-      case Failure(:boom)
-      in Result::Success[value] then "success: #{value}"
-      in Result::Failure[error] then "failure: #{error}"
-      end
-
-    expect(matched).to eq("failure: boom")
-  end
-
-  it "deconstructs by keys using the variant's field names" do
-    matched =
-      case Success(42)
-      in Result::Success(s:) then s
-      in Result::Failure(f:) then f
-      end
-
-    expect(matched).to eq(42)
-  end
-
-  it "deconstructs Some and None" do
-    some_result =
-      case Some(7)
-      in Option::Some[v] then v
-      in Option::None then :none
-      end
-    none_result =
-      case None()
-      in Option::Some[v] then v
-      in Option::None then :none
-      end
-
-    expect(some_result).to eq(7)
-    expect(none_result).to eq(:none)
-  end
-
-  Shape = FunctionalLightService.enum do
-    Point(:x, :y)
-    Origin()
-  end
-
-  it "deconstructs multi-field (Binary) variants by keys" do
-    matched =
-      case Shape::Point.new(1, 2)
-      in Shape::Point(x:, y:) then [x, y]
-      in Shape::Origin then [0, 0]
-      end
-
-    expect(matched).to eq([1, 2])
-  end
-
-  def None # rubocop:disable Naming/MethodName
-    FunctionalLightService::Option::None.new
-  end
-end

data/spec/localization_adapter_spec.rb

@@ -1,83 +0,0 @@
-require "spec_helper"
-require 'test_doubles'
-
-describe FunctionalLightService::LocalizationAdapter do
-  let(:action_class) { TestDoubles::AnAction }
-  let(:adapter) { described_class.new }
-
-  describe "#failure" do
-    subject { adapter.failure(message_or_key, action_class) }
-
-    context "when provided a Symbol" do
-      let(:message_or_key) { :not_found }
-
-      it "translates the message" do
-        expected_scope = "test_doubles/an_action.light_service.failures"
-
-        expect(I18n).to receive(:t)
-          .with(message_or_key, :scope => expected_scope)
-          .and_return("message")
-
-        expect(subject).to eq("message")
-      end
-
-      it "allows passing interpolation options to I18n layer" do
-        expect(I18n).to receive(:t)
-          .with(message_or_key, hash_including(:i18n_variable => "value"))
-          .and_return("message")
-
-        subject = adapter.failure(message_or_key,
-                                  action_class,
-                                  :i18n_variable => "value")
-
-        expect(subject).to eq("message")
-      end
-    end
-
-    context "when provided a String" do
-      let(:message_or_key) { "action failed" }
-
-      it "returns the message" do
-        expect(subject).to eq(message_or_key)
-      end
-    end
-  end
-
-  describe "#success" do
-    subject { adapter.success(message_or_key, action_class) }
-
-    context "when provided a Symbol" do
-      let(:message_or_key) { :not_found }
-
-      it "translates the message" do
-        expected_scope = "test_doubles/an_action.light_service.successes"
-
-        expect(I18n).to receive(:t)
-          .with(message_or_key, :scope => expected_scope)
-          .and_return("message")
-
-        expect(subject).to eq("message")
-      end
-
-      it "allows passing interpolation options to I18n layer" do
-        expect(I18n).to receive(:t)
-          .with(message_or_key, hash_including(:i18n_variable => "value"))
-          .and_return("message")
-
-        subject = adapter.success(message_or_key,
-                                  action_class,
-                                  :i18n_variable => "value")
-
-        expect(subject).to eq("message")
-      end
-    end
-
-    context "when provided a String" do
-      let(:message_or_key) { "action failed" }
-
-      it "returns the message" do
-        expect(subject).to eq(message_or_key)
-      end
-    end
-  end
-end

data/spec/organizer/with_reducer_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-describe FunctionalLightService::Organizer::WithReducer do
-  let(:context) { FunctionalLightService::Context.make }
-  let(:action1) { TestDoubles::NullAction }
-  let(:action2) { TestDoubles::NullAction.clone }
-  let(:actions) { [action1, action2] }
-
-  before { context.current_action = action2 }
-
-  it "reduces the provided actions" do
-    result = described_class.new.with(context).reduce(actions)
-
-    expect(result).to eq(context)
-    expect(result).to be_success
-  end
-
-  it "executes a handler around each action and continues reducing" do
-    expect(action1).to receive(:execute).with(context).and_return(context)
-
-    result = described_class.new.with(context)
-                            .around_each(TestDoubles::AroundEachNullHandler)
-                            .reduce([action1])
-
-    expect(result).to eq(context)
-    expect(result).to be_success
-  end
-
-  context "when FailWithRollbackError is caught" do
-    it "reduces the rollback" do
-      expect(action1).to receive(:execute).with(context).and_return(context)
-      expect(action2).to receive(:execute).with(context) do
-        raise FunctionalLightService::FailWithRollbackError
-      end
-      expect(action1).to receive(:rollback).with(context).and_return(context)
-      expect(action2).to receive(:rollback).with(context).and_return(context)
-
-      result = described_class.new.with(context).reduce(actions)
-
-      expect(result).to eq(context)
-    end
-
-    it "reduces the rollback with an action without `rollback`" do
-      expect(action1).to receive(:execute).with(context).and_return(context)
-      expect(action2).to receive(:execute).with(context) do
-        raise FunctionalLightService::FailWithRollbackError
-      end
-      expect(action2).to receive(:rollback).with(context).and_return(context)
-
-      result = described_class.new.with(context).reduce(actions)
-
-      expect(result).to eq(context)
-    end
-  end
-end

data/spec/organizer_key_aliases_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-describe "organizer aliases macro" do
-  let(:organizer_with_alias) do
-    Class.new do
-      extend FunctionalLightService::Organizer
-
-      aliases :promised_key => :expected_key
-
-      def self.call(ctx = {})
-        with(ctx).reduce(
-          [
-            TestDoubles::PromisesPromisedKeyAction,
-            TestDoubles::ExpectsExpectedKeyAction
-          ]
-        )
-      end
-    end
-  end
-
-  context "when aliases is invoked" do
-    it "makes aliases available to the actions" do
-      result = organizer_with_alias.call
-      expect(result[:expected_key]).to eq(result[:promised_key])
-      expect(result.expected_key).to eq(result[:promised_key])
-    end
-  end
-end

data/spec/organizer_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require 'test_doubles'
-
-describe FunctionalLightService::Organizer do
-  let(:ctx) { FunctionalLightService::Context.make(:user => user) }
-  let(:user) { double(:user) }
-
-  context "when #with is called with hash" do
-    before do
-      expect(TestDoubles::AnAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-      expect(TestDoubles::AnotherAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-    end
-
-    it "implicitly creates a Context" do
-      result = TestDoubles::AnOrganizer.call(:user => user)
-      expect(result).to eq(ctx)
-    end
-
-    it "sets itself as the organizer" do
-      result = TestDoubles::AnOrganizer.call(:user => user)
-      expect(result.organized_by).to eq TestDoubles::AnOrganizer
-    end
-  end
-
-  context "when #with is called with Context" do
-    before do
-      expect(TestDoubles::AnAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-      expect(TestDoubles::AnotherAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-    end
-
-    it "uses that Context without recreating it" do
-      result = TestDoubles::AnOrganizer.call(ctx)
-      expect(result).to eq(ctx)
-    end
-  end
-
-  context "when no Actions are specified" do
-    it "throws a Runtime error" do
-      expect { TestDoubles::AnOrganizer.do_something_with_no_actions(ctx) }.to \
-        raise_error(RuntimeError, "No action(s) were provided")
-    end
-  end
-
-  context "when aliases are declared" do
-    let(:organizer) do
-      Class.new do
-        extend FunctionalLightService::Organizer
-
-        aliases :foo => :bar
-
-        def self.call
-          with.reduce(TestDoubles::AnAction)
-        end
-      end
-    end
-
-    it "merges the aliases into the data" do
-      with_reducer = double(:reduce => true)
-
-      allow(described_class::WithReducerFactory).to receive(:make)
-        .and_return(with_reducer)
-
-      expect(with_reducer).to receive(:with)
-        .with(hash_including(:_aliases => { :foo => :bar }))
-        .and_return(with_reducer)
-
-      organizer.call
-    end
-  end
-
-  context "when an organizer is nested and reduced within another" do
-    let(:reduced) { TestDoubles::NestingOrganizer.call(ctx) }
-    let(:organizer_result) do
-      TestDoubles::NotExplicitlyReturningContextOrganizer.call(ctx)
-    end
-
-    it "reduces an organizer which returns something" do
-      expect(organizer_result).to eq([1, 2, 3])
-    end
-
-    it "adds :foo and :bar to the context" do
-      reduced
-      expect(ctx[:foo]).to eq([1, 2, 3])
-      expect(ctx[:bar]).to eq(ctx[:foo])
-    end
-
-    it "returns the context" do
-      expect(reduced).to eq(ctx)
-    end
-  end
-
-  context "can add items to the context" do
-    specify 'with #add_to_context' do
-      result = TestDoubles::AnOrganizerThatAddsToContext.call
-      expect(result[:strongest_avenger]).to eq :thor
-      expect(result[:last_jedi]).to eq "Rey"
-    end
-  end
-
-  context "can assign key aliaeses" do
-    it 'with #add_aliases' do
-      result = TestDoubles::AnOrganizerThatAddsAliases.call
-      expect(result[:foo]).to eq :bar
-      expect(result[:baz]).to eq :bar
-    end
-  end
-end

data/spec/readme_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-include FunctionalLightService::Prelude::Result
-
-Success(1).to_s                        # => "1"
-Success(Success(1))                    # => Success(1)
-
-Failure(1).to_s                        # => "1"
-Failure(Failure(1))                    # => Failure(1)
-
-Success(1).fmap { |v| v + 1 }           # => Success(2)
-Failure(1).fmap { |v| v - 1 }           # => Failure(0)
-
-Threenum = FunctionalLightService.enum do
-  Nullary()
-  Unary(:a)
-  Binary(:a, :b)
-end
-
-FunctionalLightService.impl(Threenum) do
-  def sum
-    match do
-      Nullary() {        0 }
-      Unary()   { |u|    u }
-      Binary()  { |a, b| a + b }
-    end
-  end
-
-  def +(other)
-    match do
-      Nullary() {        other.sum }
-      Unary()   { |_a|   sum + other.sum }
-      Binary()  { |_a, _b| sum + other.sum }
-    end
-  end
-end
-
-describe Threenum do
-  it "works" do
-    expect(Threenum.Nullary + Threenum.Unary(1)).to eq 1
-    expect(Threenum.Nullary + Threenum.Binary(2, 3)).to eq 5
-    expect(Threenum.Unary(1) + Threenum.Binary(2, 3)).to eq 6
-    expect(Threenum.Binary(2, 3) + Threenum.Binary(2, 3)).to eq 10
-  end
-end

data/spec/sample/calculates_order_tax_action_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require_relative 'tax/calculates_order_tax_action'
-
-describe CalculatesOrderTaxAction do
-  let(:order) { double('order') }
-  let(:context) do
-    data = { :order => order, :tax_percentage => 7.2 }
-    FunctionalLightService::Context.make(data)
-  end
-
-  it "calculates the tax based on the tax percentage" do
-    allow(order).to receive_messages(:total => 100)
-    expect(order).to receive(:tax=).with 7.2
-    CalculatesOrderTaxAction.execute(context)
-  end
-end