fear 0.9.0 → 1.2.0

data/spec/fear/extractor_api_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::ExtractorApi do
+  def assert(value)
+    expect(value).to eq(true)
+  end
+
+  def assert_not(value)
+    expect(value).not_to eq(true)
+  end
+
+  def assert_invalid_syntax
+    expect do
+      yield
+    end.to raise_error(Fear::PatternSyntaxError)
+  end
+
+  def assert_valid_syntax
+    expect { yield }.not_to raise_error
+  end
+
+  specify "Array" do
+    assert(Fear["[]"] === [])
+    assert_not(Fear["[]"] === [1])
+    assert(Fear["[1]"] === [1])
+    assert_not(Fear["[1]"] === [1, 2])
+    assert_not(Fear["[1]"] === [2])
+    assert(Fear["[1, 2]"] === [1, 2])
+    assert_not(Fear["[1, 2]"] === [1, 3])
+    assert_not(Fear["[1, 2]"] === [1, 2, 4])
+    assert_not(Fear["[1, 2]"] === [1])
+    assert(Fear["[*]"] === [])
+    assert(Fear["[*]"] === [1, 2])
+    assert_not(Fear["[1, *]"] === [])
+    assert(Fear["[1, *]"] === [1])
+    assert(Fear["[1, *]"] === [1, 2])
+    assert(Fear["[1, *]"] === [1, 2, 3])
+    assert(Fear["[[1]]"] === [[1]])
+    assert(Fear["[[1],2]"] === [[1], 2])
+    assert(Fear["[[1],*]"] === [[1], 2])
+    assert(Fear["[[*],*]"] === [[1], 2])
+    assert_invalid_syntax { Fear["[*, 2]"] }
+    assert_invalid_syntax { Fear["[*, ]"] }
+    assert_invalid_syntax { Fear["[1, *, ]"] }
+    assert_invalid_syntax { Fear["[1, *, 2]"] }
+    assert_invalid_syntax { Fear["[1, *, *]"] }
+    assert_invalid_syntax { Fear["[*, *]"] }
+    assert(Fear["[a, b]"] === [1, 2])
+    assert_not(Fear["[a, b, c]"] === [1, 2])
+    assert(Fear["[a, b, _]"] === [1, 2, 3])
+    assert(Fear["[a, b, *c]"] === [1, 2])
+    assert_not(Fear["[a, b, c, *d]"] === [1, 2])
+  end
+
+  specify "String" do
+    assert(Fear['"foo"'] === "foo")
+    assert(Fear['"f\"oo"'] === 'f"oo')
+    assert_not(Fear['"foo"'] === "bar")
+    assert(Fear["'foo'"] === "foo")
+    assert_not(Fear["'foo'"] === "bar")
+  end
+
+  specify "Symbol" do
+    assert(Fear[':"foo"'] === :foo)
+    assert(Fear[":'foo'"] === :foo)
+    assert(Fear[":foo"] === :foo)
+    assert_not(Fear[":foo"] === :bar)
+  end
+
+  specify "Boolean" do
+    assert(Fear["true"] === true)
+    assert(Fear["false"] === false)
+    assert_not(Fear["true"] === false)
+    assert_not(Fear["false"] === true)
+  end
+
+  specify "Nil" do
+    assert(Fear["nil"] === nil) # rubocop:disable Style/NilComparison
+    assert_not(Fear["nil"] === 42)
+  end
+
+  specify "_" do
+    assert(Fear["_"] === nil) # rubocop:disable Style/NilComparison
+    assert(Fear["_"] === true)
+    assert(Fear["_"] === false)
+    assert(Fear["_"] === 42)
+    assert(Fear["_"] === "foo")
+    assert(Fear["_"] === [42])
+  end
+
+  specify "type matching" do
+    class Foo
+      class Bar
+      end
+    end
+
+    assert(Fear["Integer"] === 3)
+    assert_not(Fear["Integer"] === "3")
+    assert(Fear["Numeric"] === 3)
+    assert(Fear["Foo::Bar"] === Foo::Bar.new)
+    assert(Fear["var : Integer"] === 3)
+    assert_not(Fear["var : Integer"] === "3")
+  end
+
+  specify "capture matcher" do
+    assert(Fear["array @ [head : Integer, *tail]"] === [1, 2])
+    assert_not(Fear["array @ [head : Integer, *tail]"] === ["1", 2])
+  end
+
+  specify "extractor" do
+    assert_valid_syntax { Fear["Foo(a, b : Integer)"] }
+    assert(Fear["Fear::Some(a : Integer)"] === Fear.some(42))
+    assert_not(Fear["Fear::Some(a : Integer)"] === Fear.some("foo"))
+  end
+end

data/spec/fear/extractor_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor do
+  describe ".register_extractor" do
+    Foo = ::Struct.new(:v1, :v2)
+    let(:matcher) do
+      Fear.matcher do |m|
+        m.case(Fear["Foo(43, second : Integer)"]) { |second| "43 and #{second}" }
+        m.case(Fear["Foo(42, second : Integer)"]) { |second| "42 and #{second}" }
+        m.else { "no match" }
+      end
+    end
+
+    let(:extractor) do
+      Fear.case(Foo) { |foo| [foo.v1, foo.v2] }.lift
+    end
+
+    context "extractor not registered" do
+      it "raise Fear::Extractor::ExtractorNotFound" do
+        expect do
+          described_class.find_extractor("UnknownExtractor")
+        end.to raise_error(Fear::Extractor::ExtractorNotFound)
+      end
+    end
+
+    context "register by name" do
+      let(:extractor) { ->(*) { Fear.some("matched") } }
+
+      before do
+        described_class.register_extractor(
+          "ExtractorRegisteredByName",
+          "ExtractorRegisteredByName2",
+          extractor,
+        )
+      end
+
+      it "returns extractor" do
+        expect(described_class.find_extractor("ExtractorRegisteredByName")).to eq(extractor)
+        expect(described_class.find_extractor("ExtractorRegisteredByName2")).to eq(extractor)
+      end
+    end
+
+    context "register by class" do
+      let(:extractor) { ->(*) { Fear.some("matched") } }
+      ExtractorRegisteredByClass = Class.new
+
+      before do
+        described_class.register_extractor(
+          ExtractorRegisteredByClass,
+          "ExtractorRegisteredByClass2",
+          extractor,
+        )
+      end
+
+      it "returns extractor" do
+        expect(described_class.find_extractor("ExtractorRegisteredByClass")).to eq(extractor)
+        expect(described_class.find_extractor("ExtractorRegisteredByClass2")).to eq(extractor)
+      end
+    end
+  end
+end

data/spec/fear/failure_spec.rb

@@ -1,118 +1,218 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Failure do
-  let(:exception) { RuntimeError.new('error') }
-  let(:failure) { Failure(exception) }
+  let(:exception) { RuntimeError.new("error") }
+  let(:failure) { Fear.failure(exception) }
 
   it_behaves_like Fear::RightBiased::Left do
     let(:left) { failure }
   end
 
-  describe '#exception' do
+  describe "#exception" do
     subject { failure.exception }
     it { is_expected.to eq(exception) }
   end
 
-  describe '#success?' do
+  describe "#success?" do
     subject { failure }
     it { is_expected.not_to be_success }
   end
 
-  describe '#failure?' do
+  describe "#failure?" do
     subject { failure }
     it { is_expected.to be_failure }
   end
 
-  describe '#get' do
+  describe "#get" do
     subject { proc { failure.get } }
-    it { is_expected.to raise_error(RuntimeError, 'error') }
+    it { is_expected.to raise_error(RuntimeError, "error") }
   end
 
-  describe '#or_else' do
-    context 'default does not fail' do
-      subject { failure.or_else { Fear::Success.new('value') } }
-      it { is_expected.to eq(Fear::Success.new('value')) }
+  describe "#or_else" do
+    context "default does not fail" do
+      subject { failure.or_else { Fear::Success.new("value") } }
+      it { is_expected.to eq(Fear::Success.new("value")) }
     end
 
-    context 'default fails with error' do
-      subject(:or_else) { failure.or_else { fail 'unexpected error' } }
+    context "default fails with error" do
+      subject(:or_else) { failure.or_else { raise "unexpected error" } }
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { or_else.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { or_else.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  describe '#flatten' do
+  describe "#flatten" do
     subject { failure.flatten }
     it { is_expected.to eq(failure) }
   end
 
-  describe '#select' do
-    subject { failure.select { |v| v == 'value' } }
+  describe "#select" do
+    subject { failure.select { |v| v == "value" } }
     it { is_expected.to eq(failure) }
   end
 
-  context '#recover_with' do
-    context 'block does not fail' do
+  context "#recover_with" do
+    context "block matches the error and does not fail" do
+      subject do
+        failure.recover_with do |m|
+          m.case(RuntimeError) { |error| Fear.success(error.message) }
+        end
+      end
+
+      it "returns result of evaluation of the block against the error" do
+        is_expected.to eq(Fear::Success.new("error"))
+      end
+    end
+
+    context "block does not match the error" do
       subject do
-        failure.recover_with do |error|
-          Success(error.message)
+        failure.recover_with do |m|
+          m.case(ZeroDivisionError) { Fear.success(0) }
         end
       end
 
-      it 'returns result of evaluation of the block against the error' do
-        is_expected.to eq(Fear::Success.new('error'))
+      it "returns the same failure" do
+        is_expected.to eq(failure)
       end
     end
 
-    context 'block fails' do
-      subject(:recover_with) { failure.recover_with { fail 'unexpected error' } }
+    context "block fails" do
+      subject(:recover_with) { failure.recover_with { raise "unexpected error" } }
 
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { recover_with.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { recover_with.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  context '#recover' do
-    context 'block does not fail' do
-      subject { failure.recover(&:message) }
+  context "#recover" do
+    context "block matches the error and does not fail" do
+      subject do
+        failure.recover do |m|
+          m.case(RuntimeError, &:message)
+        end
+      end
 
-      it 'returns Success of evaluation of the block against the error' do
-        is_expected.to eq(Success('error'))
+      it "returns Success of evaluation of the block against the error" do
+        is_expected.to eq(Fear.success("error"))
       end
     end
 
-    context 'block fails' do
-      subject(:recover) { failure.recover { fail 'unexpected error' } }
+    context "block does not match the error" do
+      subject do
+        failure.recover do |m|
+          m.case(ZeroDivisionError, &:message)
+        end
+      end
+
+      it "returns the same failure" do
+        is_expected.to eq(failure)
+      end
+    end
+
+    context "block fails" do
+      subject(:recover) do
+        failure.recover do
+          raise "unexpected error"
+        end
+      end
 
       it { is_expected.to be_kind_of(described_class) }
-      it { expect { recover.get }.to raise_error(RuntimeError, 'unexpected error') }
+      it { expect { recover.get }.to raise_error(RuntimeError, "unexpected error") }
     end
   end
 
-  describe '#to_either' do
+  describe "#to_either" do
     subject { failure.to_either }
-    it { is_expected.to eq(Left(exception)) }
+    it { is_expected.to eq(Fear.left(exception)) }
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === failure }
 
-    context 'matches erectly' do
-      let(:match) { Failure(exception) }
+    context "matches erectly" do
+      let(:match) { Fear.failure(exception) }
       it { is_expected.to eq(true) }
     end
 
-    context 'value does not match' do
-      let(:match) { Failure(ArgumentError.new) }
+    context "value does not match" do
+      let(:match) { Fear.failure(ArgumentError.new) }
       it { is_expected.to eq(false) }
     end
 
-    context 'matches by class' do
-      let(:match) { Failure(RuntimeError) }
+    context "matches by class" do
+      let(:match) { Fear.failure(RuntimeError) }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not matches by class' do
-      let(:match) { Failure(ArgumentError) }
+    context "does not matches by class" do
+      let(:match) { Fear.failure(ArgumentError) }
       it { is_expected.to eq(false) }
     end
   end
+
+  describe "#match" do
+    context "matched" do
+      subject do
+        failure.match do |m|
+          m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
+          m.failure(->(x) { x.message.length > 2 }) { |x| "Error: #{x}" }
+          m.success(->(x) { x.length > 2 }) { |x| "Success: #{x}" }
+        end
+      end
+
+      it { is_expected.to eq("Error: error") }
+    end
+
+    context "nothing matched and no else given" do
+      subject do
+        proc do
+          failure.match do |m|
+            m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
+            m.success { "noop" }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context "nothing matched and else given" do
+      subject do
+        failure.match do |m|
+          m.failure(->(x) { x.message.length < 2 }) { |x| "Error: #{x}" }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
+
+  describe "#to_s" do
+    subject { failure.to_s }
+
+    it { is_expected.to eq("#<Fear::Failure exception=#<RuntimeError: error>>") }
+  end
+
+  describe "pattern matching" do
+    subject { Fear.xcase("Failure(v : ArgumentError)") { "matched" }.call_or_else(var) { "nothing" } }
+
+    context "failure of ArgumentError" do
+      let(:var) { Fear.failure(ArgumentError.new) }
+
+      it { is_expected.to eq("matched") }
+    end
+
+    context "failure of RuntimeError" do
+      let(:var) { Fear.failure(RuntimeError.new) }
+
+      it { is_expected.to eq("nothing") }
+    end
+
+    context "not failure" do
+      let(:var) { "42" }
+
+      it { is_expected.to eq("nothing") }
+    end
+  end
 end

data/spec/fear/for_spec.rb

@@ -1,123 +1,113 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::For do
-  context 'unary' do
-    context 'Some' do
+  context "unary" do
+    context "Some" do
       subject do
-        For(a: Some(2)) { a * 2 }
+        Fear.for(Fear.some(2)) { |a| a * 2 }
       end
 
-      it { is_expected.to eq(Some(4)) }
+      it { is_expected.to eq(Fear.some(4)) }
     end
 
-    context 'None' do
+    context "None" do
       subject do
-        For(a: None()) { a * 2 }
+        Fear.for(Fear.none) { |a| a * 2 }
       end
 
-      it { is_expected.to eq(None()) }
+      it { is_expected.to eq(Fear.none) }
     end
   end
 
-  context 'access method from outer scope' do
-    def two
-      2
-    end
-    private :two
-
+  context "arrays" do
     subject do
-      For(a: Some(2)) { a * two }
-    end
-
-    it { is_expected.to eq(Some(4)) }
-  end
-
-  context 'arrays' do
-    subject do
-      For(a: [1, 2], b: [2, 3], c: [3, 4]) do
+      Fear.for([1, 2], [2, 3], [3, 4]) do |a, b, c|
         a * b * c
       end
     end
+
     it { is_expected.to eq([6, 8, 9, 12, 12, 16, 18, 24]) }
   end
 
-  context 'ternary' do
+  context "ternary" do
     subject do
-      For(a: first, b: second, c: third) do
+      Fear.for(first, second, third) do |a, b, c|
         a * b * c
       end
     end
 
-    context 'all Same' do
-      let(:first) { Some(2) }
-      let(:second) { Some(3) }
-      let(:third) { Some(4) }
+    context "all Same" do
+      let(:first) { Fear.some(2) }
+      let(:second) { Fear.some(3) }
+      let(:third) { Fear.some(4) }
 
-      it { is_expected.to eq(Some(24)) }
+      it { is_expected.to eq(Fear.some(24)) }
     end
 
-    context 'first is None' do
-      let(:first) { None() }
-      let(:second) { Some(3) }
-      let(:third) { Some(4) }
+    context "first is None" do
+      let(:first) { Fear.none }
+      let(:second) { Fear.some(3) }
+      let(:third) { Fear.some(4) }
 
-      it { is_expected.to eq(None()) }
+      it { is_expected.to eq(Fear.none) }
     end
 
-    context 'second is None' do
-      let(:first) { Some(2) }
-      let(:second) { None() }
-      let(:third) { Some(4) }
+    context "second is None" do
+      let(:first) { Fear.some(2) }
+      let(:second) { Fear.none }
+      let(:third) { Fear.some(4) }
 
-      it { is_expected.to eq(None()) }
+      it { is_expected.to eq(Fear.none) }
     end
 
-    context 'last is None' do
-      let(:first) { Some(2) }
-      let(:second) { Some(3) }
-      let(:third) { None() }
+    context "last is None" do
+      let(:first) { Fear.some(2) }
+      let(:second) { Fear.some(3) }
+      let(:third) { Fear.none }
 
-      it { is_expected.to eq(None()) }
+      it { is_expected.to eq(Fear.none) }
     end
 
-    context 'all Same in lambdas' do
-      let(:first) { -> { Some(2) } }
-      let(:second) { -> { Some(3) } }
-      let(:third) { -> { Some(4) } }
+    context "all Same in lambdas" do
+      let(:first) { proc { Fear.some(2) } }
+      let(:second) { proc { Fear.some(3) } }
+      let(:third) { proc { Fear.some(4) } }
 
-      it { is_expected.to eq(Some(24)) }
+      it { is_expected.to eq(Fear.some(24)) }
     end
 
-    context 'first is None in lambda, second is failure in lambda' do
-      let(:first) { -> { None() } }
-      let(:second) { -> { fail 'kaboom' } }
-      let(:third) { -> {} }
+    context "first is None in lambda, second is failure in lambda" do
+      let(:first) { proc { Fear.none } }
+      let(:second) { proc { raise "kaboom" } }
+      let(:third) { proc {} }
 
-      it 'returns None without evaluating second and third' do
-        is_expected.to eq(None())
+      it "returns None without evaluating second and third" do
+        is_expected.to eq(Fear.none)
       end
     end
 
-    context 'second is None in lambda, third is failure in lambda' do
-      let(:first) { Some(2) }
-      let(:second) { -> { None() } }
-      let(:third) { -> { fail 'kaboom' } }
+    context "second is None in lambda, third is failure in lambda" do
+      let(:first) { Fear.some(2) }
+      let(:second) { proc { Fear.none } }
+      let(:third) { proc { raise "kaboom" } }
 
-      it 'returns None without evaluating third' do
-        is_expected.to eq(None())
+      it "returns None without evaluating third" do
+        is_expected.to eq(Fear.none)
       end
     end
   end
 
-  context 'refer to previous variable from lambda' do
+  context "refer to previous variable from lambda" do
     subject do
-      For(a: first, b: second, c: third) do
+      Fear.for(first, second, third) do |_, b, c|
         b * c
       end
     end
 
-    let(:first) { Some(Some(2)) }
-    let(:second) { -> { a } }
-    let(:third) { -> { Some(3) } }
+    let(:first) { Fear.some(Fear.some(2)) }
+    let(:second) { ->(a) { a.map { |x| x * 2 } } }
+    let(:third) { proc { Fear.some(3) } }
 
-    it { is_expected.to eq(Some(6)) }
+    it { is_expected.to eq(Fear.some(12)) }
   end
 end