functional-light-service 6.2.0 → 6.3.0

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,66 +0,0 @@
-require "spec_helper"
-require 'test_doubles'
-
-describe FunctionalLightService::LocalizationAdapter do
-  let(:action_class) { TestDoubles::AnAction }
-  let(:adapter) { described_class.new }
-
-  before do
-    FunctionalLightService::LocalizationMap.instance[:en] = {
-      :'test_doubles/an_action' => {
-        :light_service => {
-          :failures => {
-            :not_found => "failure message"
-          },
-          :successes => {
-            :not_found => "success message"
-          }
-        }
-      }
-    }
-  end
-
-  after do
-    FunctionalLightService::LocalizationMap.instance.clear
-  end
-
-  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
-        expect(subject).to eq("failure 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
-        expect(subject).to eq("success 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

data/spec/sample/calculates_tax_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require_relative 'tax/calculates_tax'
-require_relative 'tax/looks_up_tax_percentage_action'
-require_relative 'tax/calculates_order_tax_action'
-require_relative 'tax/provides_free_shipping_action'
-
-describe CalculatesTax do
-  let(:order) { double('order') }
-  let(:ctx) { FunctionalLightService::Context.make(:user => nil) }
-
-  it "calls the actions in order" do
-    allow(FunctionalLightService::Context).to receive(:make)
-      .with({ :order => order })
-      .and_return(ctx)
-
-    allow(LooksUpTaxPercentageAction).to receive(:execute)
-      .with(ctx)
-      .and_return(ctx)
-    allow(CalculatesOrderTaxAction).to receive(:execute)
-      .with(ctx)
-      .and_return(ctx)
-    allow(ProvidesFreeShippingAction).to receive(:execute)
-      .with(ctx)
-      .and_return(ctx)
-
-    result = CalculatesTax.call(order)
-
-    expect(result).to eq(ctx)
-  end
-end

data/spec/sample/looks_up_tax_percentage_action_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-require_relative 'tax/looks_up_tax_percentage_action'
-
-class TaxRange
-  extend FunctionalLightService::Action
-end
-
-describe LooksUpTaxPercentageAction do
-  let(:region) { double('region') }
-  let(:order) do
-    order = double('order')
-    allow(order).to receive_messages(:region => region)
-    allow(order).to receive_messages(:total => 200)
-    order
-  end
-  let(:context) do
-    FunctionalLightService::Context.make(:order => order)
-  end
-  let(:tax_percentage) { double('tax_percentage') }
-  let(:tax_ranges) { double('tax_ranges') }
-
-  context "when the tax_ranges were not found" do
-    it "sets the context to failure" do
-      allow(TaxRange).to receive(:for_region).with(region).and_return nil
-      LooksUpTaxPercentageAction.execute(context)
-
-      expect(context).to be_failure
-      expect(context.message).to eq "The tax ranges were not found"
-    end
-  end
-
-  context "when the tax_percentage is not found" do
-    it "sets the context to failure" do
-      allow(TaxRange).to receive(:for_region).with(region).and_return tax_ranges
-      allow(tax_ranges).to receive_messages(:for_total => nil)
-
-      LooksUpTaxPercentageAction.execute(context)
-
-      expect(context).to be_failure
-      expect(context.message).to eq "The tax percentage was not found"
-    end
-  end
-
-  context "when the tax_percentage is found" do
-    it "sets the tax_percentage in context" do
-      allow(TaxRange).to receive(:for_region).with(region).and_return tax_ranges
-      allow(tax_ranges).to receive_messages(:for_total => 25)
-
-      LooksUpTaxPercentageAction.execute(context)
-
-      expect(context).to be_success
-      expect(context.fetch(:tax_percentage)).to eq 25
-    end
-  end
-end

data/spec/sample/provides_free_shipping_action_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-require_relative 'tax/provides_free_shipping_action'
-
-describe ProvidesFreeShippingAction do
-  let(:order) { double('order') }
-  let(:ctx) { { :order => order } }
-
-  context "when the order total with tax is > 200" do
-    specify "order gets free shipping" do
-      allow(order).to receive_messages(:total_with_tax => 201)
-      expect(order).to receive(:provide_free_shipping!)
-
-      ProvidesFreeShippingAction.execute(ctx)
-    end
-  end
-
-  context "when the order total with tax is <= 200" do
-    specify "order does not get free shipping" do
-      allow(order).to receive_messages(:total_with_tax => 200)
-      expect(order).not_to receive(:provide_free_shipping!)
-
-      ProvidesFreeShippingAction.execute(ctx)
-    end
-  end
-end

data/spec/sample/tax/calculates_order_tax_action.rb

@@ -1,10 +0,0 @@
-class CalculatesOrderTaxAction
-  extend ::FunctionalLightService::Action
-
-  expects :order, :tax_percentage
-
-  executed do |ctx|
-    order_total = (ctx.order.total * (ctx.tax_percentage / 100))
-    ctx.order.tax = order_total.round(2)
-  end
-end

data/spec/sample/tax/calculates_tax.rb

@@ -1,11 +0,0 @@
-class CalculatesTax
-  extend FunctionalLightService::Organizer
-
-  def self.call(order)
-    with(:order => order).reduce(
-      LooksUpTaxPercentageAction,
-      CalculatesOrderTaxAction,
-      ProvidesFreeShippingAction
-    )
-  end
-end

data/spec/sample/tax/looks_up_tax_percentage_action.rb

@@ -1,28 +0,0 @@
-class LooksUpTaxPercentageAction
-  extend FunctionalLightService::Action
-
-  expects :order
-  promises :tax_percentage
-
-  executed do |ctx|
-    tax_ranges = TaxRange.for_region(ctx.order.region)
-    ctx.tax_percentage = 0
-
-    next ctx if object_is_nil?(tax_ranges, ctx, 'The tax ranges were not found')
-
-    ctx.tax_percentage = tax_ranges.for_total(ctx.order.total)
-
-    error_message = 'The tax percentage was not found'
-    next ctx if object_is_nil?(ctx.tax_percentage, ctx, error_message)
-  end
-
-  def self.object_is_nil?(object, ctx, message)
-    if object.nil?
-      ctx.fail!(message)
-      return true
-    end
-
-    false
-  end
-  private_class_method :object_is_nil?
-end

data/spec/sample/tax/provides_free_shipping_action.rb

@@ -1,11 +0,0 @@
-class ProvidesFreeShippingAction
-  extend FunctionalLightService::Action
-
-  expects :order
-
-  executed do |context|
-    order = context.order
-
-    order.provide_free_shipping! if order.total_with_tax > 200
-  end
-end