fear 0.11.0 → 1.0.0

data/spec/fear/extractor_api_spec.rb

@@ -0,0 +1,113 @@
+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,59 @@
+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,6 +1,6 @@
 RSpec.describe Fear::Failure do
   let(:exception) { RuntimeError.new('error') }
-  let(:failure) { Failure(exception) }
+  let(:failure) { Fear.failure(exception) }
 
   it_behaves_like Fear::RightBiased::Left do
     let(:left) { failure }
@@ -50,10 +50,10 @@ RSpec.describe Fear::Failure do
   end
 
   context '#recover_with' do
-    context 'block does not fail' do
+    context 'block matches the error and does not fail' do
       subject do
-        failure.recover_with do |error|
-          Success(error.message)
+        failure.recover_with do |m|
+          m.case(RuntimeError) { |error| Fear.success(error.message) }
         end
       end
 
@@ -62,6 +62,18 @@ RSpec.describe Fear::Failure do
       end
     end
 
+    context 'block does not match the error' do
+      subject do
+        failure.recover_with do |m|
+          m.case(ZeroDivisionError) { Fear.success(0) }
+        end
+      end
+
+      it 'returns the same failure' do
+        is_expected.to eq(failure)
+      end
+    end
+
     context 'block fails' do
       subject(:recover_with) { failure.recover_with { raise 'unexpected error' } }
 
@@ -71,16 +83,36 @@ RSpec.describe Fear::Failure do
   end
 
   context '#recover' do
-    context 'block does not fail' do
-      subject { failure.recover(&:message) }
+    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'))
+        is_expected.to eq(Fear.success('error'))
+      end
+    end
+
+    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) { failure.recover { raise 'unexpected error' } }
+      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') }
@@ -89,29 +121,29 @@ RSpec.describe Fear::Failure 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
     subject { match === failure }
 
     context 'matches erectly' do
-      let(:match) { Failure(exception) }
+      let(:match) { Fear.failure(exception) }
       it { is_expected.to eq(true) }
     end
 
     context 'value does not match' do
-      let(:match) { Failure(ArgumentError.new) }
+      let(:match) { Fear.failure(ArgumentError.new) }
       it { is_expected.to eq(false) }
     end
 
     context 'matches by class' do
-      let(:match) { Failure(RuntimeError) }
+      let(:match) { Fear.failure(RuntimeError) }
       it { is_expected.to eq(true) }
     end
 
     context 'does not matches by class' do
-      let(:match) { Failure(ArgumentError) }
+      let(:match) { Fear.failure(ArgumentError) }
       it { is_expected.to eq(false) }
     end
   end
@@ -153,4 +185,32 @@ RSpec.describe Fear::Failure do
       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

@@ -2,24 +2,24 @@ RSpec.describe Fear::For do
   context 'unary' do
     context 'Some' do
       subject do
-        For(Some(2)) { |a| 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
       subject do
-        For(None()) { |a| 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 'arrays' do
     subject do
-      For([1, 2], [2, 3], [3, 4]) do |a, b, c|
+      Fear.for([1, 2], [2, 3], [3, 4]) do |a, b, c|
         a * b * c
       end
     end
@@ -29,83 +29,83 @@ RSpec.describe Fear::For do
 
   context 'ternary' do
     subject do
-      For(first, second, third) do |a, b, c|
+      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) }
+      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) }
+      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) }
+      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() }
+      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) { proc { Some(2) } }
-      let(:second) { proc { Some(3) } }
-      let(:third) { proc { Some(4) } }
+      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) { proc { None() } }
+      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())
+        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) { proc { None() } }
+      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())
+        is_expected.to eq(Fear.none)
       end
     end
   end
 
   context 'refer to previous variable from lambda' do
     subject do
-      For(first, second, third) do |_, b, c|
+      Fear.for(first, second, third) do |_, b, c|
         b * c
       end
     end
 
-    let(:first) { Some(Some(2)) }
+    let(:first) { Fear.some(Fear.some(2)) }
     let(:second) { ->(a) { a.map { |x| x * 2 } } }
-    let(:third) { proc { Some(3) } }
+    let(:third) { proc { Fear.some(3) } }
 
-    it { is_expected.to eq(Some(12)) }
+    it { is_expected.to eq(Fear.some(12)) }
   end
 end