functional-light-service 0.2.4

data/spec/lib/deterministic/result_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe FunctionalLightService::Result do
+  include FunctionalLightService::Prelude::Result
+
+  it "can't call Result#new directly" do
+    msg = "private method `new' called for FunctionalLightService::Result:Class"
+    expect { described_class.new(1) }.to raise_error(NoMethodError, msg)
+  end
+
+  it "fmap" do
+    expect(Success(1).fmap { |n| n + 1 }).to eq Success(2)
+    expect(Failure(0).fmap { |n| n + 1 }).to eq Failure(1)
+  end
+
+  it "map" do
+    expect(Success(1).map { |n| Success(n + 1) }).to eq Success(2)
+    expect(Failure(0).map { |n| Success(n + 1) }).to eq Failure(0)
+  end
+
+  it "+" do
+    expect(Success([1]) + Failure([2])).to eq Failure([2])
+    expect(Success(1) + Success(1)).to eq Success(2)
+    expect(Failure(2) + Success(1)).to eq Failure(2)
+    expect(Failure([2]) + Failure([3]) + Success(1)).to eq Failure([2, 3])
+    expect(Success([1]) + Success([1])).to eq Success([1, 1])
+    expect { Success([1]) + Success(1) }.to raise_error TypeError
+  end
+
+  subject { Success(1) }
+  # specify { expect(subject).to be_an_instance_of described_class }
+  specify { expect(subject).to be_success }
+  specify { expect(subject).not_to be_failure }
+  specify { expect(subject.success?).to be_truthy }
+  specify { expect(subject.failure?).to be_falsey }
+
+  specify { expect(subject).to be_a described_class }
+  # specify { expect(subject).to eq(described_class.new(1)) }
+  specify { expect(subject.fmap { |v| v + 1 }).to eq Success(2) }
+  specify { expect(subject.map { |v| Failure(v + 1) }).to eq Failure(2) }
+  specify { expect(subject.map_err { |v| Failure(v + 1) }).to eq Success(1) }
+
+  specify do
+    expect(subject.pipe do |r|
+             raise RuntimeError unless r == Success(1)
+           end).to eq Success(1)
+  end
+
+  specify { expect(subject.or(Success(2))).to eq Success(1) }
+  specify { expect(subject.or_else { Success(2) }).to eq Success(1) }
+
+  specify { expect(subject.and(Success(2))).to eq Success(2) }
+  specify { expect(subject.and(Failure(2))).to eq Failure(2) }
+  specify { expect(subject.and_then { Success(2) }).to eq Success(2) }
+  specify { expect(subject.and_then { Failure(2) }).to eq Failure(2) }
+
+  it "try!" do
+    expect(described_class.try! { 1 }).to eq Success(1)
+    expect(described_class.try! { raise "error" }.inspect).to \
+      eq Failure(RuntimeError.new("error")).inspect
+  end
+end
+

data/spec/lib/enum_spec.rb

@@ -0,0 +1,112 @@
+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' called for MyEnym:Class"
+    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 ""
+      expect(n.fmap {}).to eq n
+    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/localization_adapter_spec.rb

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

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

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

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

data/spec/readme_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+# rubocop:disable Style/MixinUsage
+include FunctionalLightService::Prelude::Result
+# rubocop:enable Style/MixinUsage
+
+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

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

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require_relative 'tax/looks_up_tax_percentage_action'
+
+class TaxRange; 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

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

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

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

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

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