fear 0.11.0 → 1.0.0

data/lib/fear/try_api.rb

@@ -0,0 +1,31 @@
+module Fear
+  module TryApi
+    # Constructs a +Try+ using the block. This
+    # method ensures any non-fatal exception is caught and a
+    # +Failure+ object is returned.
+    # @return [Fear::Try]
+    # @example
+    #   Fear.try { 4/0 } #=> #<Fear::Failure exception=#<ZeroDivisionError: divided by 0>>
+    #   Fear.try { 4/2 } #=> #<Fear::Success value=2>
+    #
+    def try
+      success(yield)
+    rescue StandardError => error
+      failure(error)
+    end
+
+    # @param exception [StandardError]
+    # @return [Fear::Failure]
+    #
+    def failure(exception)
+      Fear::Failure.new(exception)
+    end
+
+    # @param value [any]
+    # @return [Fear::Success]
+    #
+    def success(value)
+      Fear::Success.new(value)
+    end
+  end
+end

data/lib/fear/unit.rb

@@ -0,0 +1,28 @@
+module Fear
+  # Represents lack of value. It's typically returned when function completed without a value.
+  #
+  # @example
+  #   if user.valid?
+  #     Fear.right(Fear::Unit)
+  #   else
+  #     Fear.left(user.errors)
+  #   end
+  #
+  # @example
+  #   def sent_notifications(user)
+  #     # ...
+  #     Fear::Unit
+  #   end
+  #
+  Unit = Object.new.tap do |unit|
+    # @return [String]
+    def unit.to_s
+      '#<Fear::Unit>'
+    end
+
+    # @return [String]
+    def unit.inspect
+      '#<Fear::Unit>'
+    end
+  end.freeze
+end

data/lib/fear/version.rb

@@ -1,3 +1,3 @@
 module Fear
-  VERSION = '0.11.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/spec/fear/done_spec.rb

@@ -1,14 +1,14 @@
-RSpec.describe Fear::Done do
+RSpec.describe Fear::Unit do
   describe '#to_s' do
     subject { described_class.to_s }
 
-    it { is_expected.to eq('Done') }
+    it { is_expected.to eq('#<Fear::Unit>') }
   end
 
   describe '#inspect' do
     subject { described_class.inspect }
 
-    it { is_expected.to eq('Done') }
+    it { is_expected.to eq('#<Fear::Unit>') }
   end
 
   describe '#==' do

data/spec/fear/either/mixin_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Fear::Either::Mixin do
+  include Fear::Either::Mixin
+
+  describe 'Left()' do
+    subject { Left(42) }
+
+    it { is_expected.to eq(Fear::Left.new(42)) }
+  end
+
+  describe 'Right()' do
+    subject { Right(42) }
+
+    it { is_expected.to eq(Fear::Right.new(42)) }
+  end
+end

data/spec/fear/either_pattern_match_spec.rb

@@ -1,19 +1,17 @@
 RSpec.describe Fear::EitherPatternMatch do
-  include Fear::Either::Mixin
-
   context 'Right' do
     let(:matcher) do
       described_class.new do |m|
-        m.right(:even?) { |x| "#{x} is even" }
-        m.right(:odd?) { |x| "#{x} is odd" }
+        m.right(:even?.to_proc) { |x| "#{x} is even" }
+        m.right(:odd?.to_proc) { |x| "#{x} is odd" }
       end
     end
 
     it do
-      expect(matcher.call(Right(4))).to eq('4 is even')
-      expect(matcher.call(Right(3))).to eq('3 is odd')
+      expect(matcher.call(Fear.right(4))).to eq('4 is even')
+      expect(matcher.call(Fear.right(3))).to eq('3 is odd')
       expect do
-        matcher.call(Left(44))
+        matcher.call(Fear.left(44))
       end.to raise_error(Fear::MatchError)
     end
   end
@@ -21,16 +19,16 @@ RSpec.describe Fear::EitherPatternMatch do
   context 'Left' do
     let(:matcher) do
       described_class.new do |m|
-        m.left(:even?) { |x| "#{x} is even" }
-        m.left(:odd?) { |x| "#{x} is odd" }
+        m.left(:even?.to_proc) { |x| "#{x} is even" }
+        m.left(:odd?.to_proc) { |x| "#{x} is odd" }
       end
     end
 
     it do
-      expect(matcher.call(Left(4))).to eq('4 is even')
-      expect(matcher.call(Left(3))).to eq('3 is odd')
+      expect(matcher.call(Fear.left(4))).to eq('4 is even')
+      expect(matcher.call(Fear.left(3))).to eq('3 is odd')
       expect do
-        matcher.call(Right(44))
+        matcher.call(Fear.right(44))
       end.to raise_error(Fear::MatchError)
     end
   end

data/spec/fear/extractor/array_matcher_spec.rb

@@ -0,0 +1,228 @@
+RSpec.describe Fear::Extractor::ArrayMatcher do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe '#defined_at?' do
+    subject { matcher }
+
+    context 'empty array' do
+      let(:pattern) { '[]' }
+
+      it { is_expected.to be_defined_at([]) }
+      it { is_expected.not_to be_defined_at([1]) }
+    end
+
+    context 'empty array with splat' do
+      let(:pattern) { '[*]' }
+
+      it { is_expected.to be_defined_at([]) }
+      it { is_expected.to be_defined_at([1]) }
+      it { is_expected.to be_defined_at([1, 2]) }
+    end
+
+    context 'empty array with named splat' do
+      let(:pattern) { '[*var]' }
+
+      it { is_expected.to be_defined_at([]) }
+      it { is_expected.to be_defined_at([1]) }
+      it { is_expected.to be_defined_at([1, 2]) }
+    end
+
+    context 'one element array' do
+      let(:pattern) { '[1]' }
+
+      it { is_expected.not_to be_defined_at([]) }
+      it { is_expected.to be_defined_at([1]) }
+      it { is_expected.not_to be_defined_at([1, 2]) }
+      it { is_expected.not_to be_defined_at([2, 1]) }
+
+      context 'identifier' do
+        let(:pattern) { '[var]' }
+
+        it { is_expected.not_to be_defined_at([]) }
+        it { is_expected.to be_defined_at([1]) }
+        it { is_expected.to be_defined_at([[1]]) }
+      end
+    end
+
+    context 'two elements array with nested matcher' do
+      let(:pattern) { '[[1, *], 1]' }
+
+      it { is_expected.not_to be_defined_at([]) }
+      it { is_expected.to be_defined_at([[1], 1]) }
+      it { is_expected.to be_defined_at([[1, 2], 1]) }
+      it { is_expected.not_to be_defined_at([[1, 2], 2]) }
+      it { is_expected.not_to be_defined_at([2, 1]) }
+    end
+
+    context 'one element array with splat' do
+      let(:pattern) { '[1, *]' }
+
+      it { is_expected.not_to be_defined_at([]) }
+      it { is_expected.to be_defined_at([1]) }
+      it { is_expected.to be_defined_at([1, 2]) }
+      it { is_expected.to be_defined_at([1, 2, 3]) }
+      it { is_expected.not_to be_defined_at([2, 1]) }
+    end
+
+    context 'one element array with named splat' do
+      let(:pattern) { '[1, *var]' }
+
+      it { is_expected.not_to be_defined_at([]) }
+      it { is_expected.to be_defined_at([1]) }
+      it { is_expected.to be_defined_at([1, 2]) }
+      it { is_expected.to be_defined_at([1, 2, 3]) }
+      it { is_expected.not_to be_defined_at([2, 1]) }
+    end
+
+    context 'three elements array' do
+      context 'with identifier in the middle' do
+        let(:pattern) { '[1, var, 2]' }
+
+        it { is_expected.not_to be_defined_at([]) }
+        it { is_expected.to be_defined_at([1, 3, 2]) }
+        it { is_expected.not_to be_defined_at([1, 2, 3]) }
+        it { is_expected.not_to be_defined_at([1, 2, 3, 4]) }
+        it { is_expected.not_to be_defined_at([1]) }
+        it { is_expected.not_to be_defined_at([2]) }
+      end
+
+      context 'head and tail' do
+        let(:pattern) { '[head, *tail]' }
+
+        it { is_expected.not_to be_defined_at([]) }
+        it { is_expected.to be_defined_at([1, 3, 2]) }
+      end
+    end
+
+    context 'two element array' do
+      let(:pattern) { '[ 1, 2 ]' }
+
+      it { is_expected.not_to be_defined_at([]) }
+      it { is_expected.to be_defined_at([1, 2]) }
+      it { is_expected.not_to be_defined_at([1]) }
+      it { is_expected.not_to be_defined_at([2]) }
+      it { is_expected.not_to be_defined_at([1, 3]) }
+      it { is_expected.not_to be_defined_at([2, 2]) }
+      it { is_expected.not_to be_defined_at([1, 2, 3]) }
+
+      context 'with identifier at the beginning' do
+        let(:pattern) { '[var, 2]' }
+
+        it { is_expected.not_to be_defined_at([]) }
+        it { is_expected.to be_defined_at([1, 2]) }
+        it { is_expected.not_to be_defined_at([1, 3]) }
+        it { is_expected.not_to be_defined_at([1]) }
+        it { is_expected.not_to be_defined_at([2]) }
+        it { is_expected.not_to be_defined_at([1, 2, 3]) }
+      end
+    end
+  end
+
+  describe '#call' do
+    subject { matcher.call(other) }
+
+    context 'on the same array' do
+      let(:other) { [1] }
+      let(:pattern) { '[1]' }
+
+      it { is_expected.to eq({}) }
+    end
+
+    context 'with splat on another array' do
+      let(:other) { [2, 1] }
+      let(:pattern) { '[2, *]' }
+
+      it { is_expected.to eq({}) }
+    end
+
+    context 'with identifier at the middle of an array' do
+      let(:other) { [2, 1, 3] }
+      let(:pattern) { '[2, var, 3]' }
+
+      it { is_expected.to eq(var: 1) }
+    end
+
+    context 'with identifier at the end of an array' do
+      let(:other) { [2, 1, 3] }
+      let(:pattern) { '[2, 1, var]' }
+
+      it { is_expected.to eq(var: 3) }
+    end
+
+    context 'with named splat matching all the array' do
+      let(:other) { [2, 1, 3, 4] }
+      let(:pattern) { '[*var]' }
+
+      it { is_expected.to eq(var: [2, 1, 3, 4]) }
+    end
+
+    context 'with named splat matching tail of an array' do
+      let(:other) { [2, 1, 3, 4] }
+      let(:pattern) { '[2, 1, *var]' }
+
+      it { is_expected.to eq(var: [3, 4]) }
+    end
+
+    context 'with named splat at the end of an array' do
+      let(:other) { [2, 1] }
+      let(:pattern) { '[2, 1, *var]' }
+
+      it { is_expected.to eq(var: []) }
+    end
+
+    context 'with several identifiers in an array' do
+      let(:other) { [2, 1, 3] }
+      let(:pattern) { '[a, 1, b]' }
+
+      it { is_expected.to eq(a: 2, b: 3) }
+    end
+
+    context 'head and tail' do
+      let(:other) { [2, 1, 3] }
+      let(:pattern) { '[head, *tail]' }
+
+      it { is_expected.to eq(head: 2, tail: [1, 3]) }
+    end
+
+    context 'ignore head, capture tail' do
+      let(:other) { [2, 1, 3] }
+      let(:pattern) { '[_, *tail]' }
+
+      it { is_expected.to eq(tail: [1, 3]) }
+    end
+  end
+
+  describe '#failure_reason' do
+    subject { matcher.failure_reason(other) }
+
+    context 'on the same array' do
+      let(:other) { [1] }
+      let(:pattern) { '[1]' }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context 'on another array' do
+      let(:other) { [2, 1] }
+      let(:pattern) { '[2, 2]' }
+
+      it { is_expected.to eq(Fear.some(<<-ERROR.strip)) }
+Expected `1` to match:
+[2, 2]
+~~~~^
+      ERROR
+    end
+
+    context 'element type mismatch' do
+      let(:other) { [2, 1] }
+      let(:pattern) { '[[2], 1]' }
+
+      it { is_expected.to eq(Fear.some(<<-ERROR.strip)) }
+Expected `2` to match:
+[[2], 1]
+~~^
+      ERROR
+    end
+  end
+end

data/spec/fear/extractor/extractor_matcher_spec.rb

@@ -0,0 +1,151 @@
+RSpec.describe Fear::Extractor::ExtractorMatcher do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe '#defined_at?' do
+    subject { matcher }
+
+    context 'boolean extractor' do
+      let(:pattern) { 'IsEven()' }
+
+      it { is_expected.to be_defined_at(42) }
+      it { is_expected.not_to be_defined_at(43) }
+      it { is_expected.not_to be_defined_at('foo') }
+    end
+
+    context 'single argument extractor' do
+      let(:pattern) { 'Fear::Some(a : Integer)' }
+
+      it { is_expected.to be_defined_at(Fear.some(42)) }
+      it { is_expected.not_to be_defined_at('foo') }
+      it { is_expected.not_to be_defined_at(Fear.some('foo')) }
+    end
+
+    context 'single argument extractor with array as an argument' do
+      let(:pattern) { 'Fear::Some([1, 2])' }
+
+      it { is_expected.to be_defined_at(Fear.some([1, 2])) }
+      it { is_expected.not_to be_defined_at(Fear.some([1, 1])) }
+      it { is_expected.not_to be_defined_at(Fear.some('foo')) }
+    end
+
+    context 'multiple arguments extractor' do
+      let(:pattern) { 'Date(2017, month, _)' }
+
+      it { is_expected.to be_defined_at(Date.parse('2017-02-15')) }
+      it { is_expected.not_to be_defined_at(Date.parse('2018-02-15')) }
+      it { is_expected.not_to be_defined_at('foo') }
+    end
+
+    context 'Struct' do
+      StructDate = Struct.new(:year, :month, :day)
+
+      let(:pattern) { 'StructDate(2017, month, _)' }
+
+      it { is_expected.to be_defined_at(StructDate.new(2017, 2, 15)) }
+      it { is_expected.not_to be_defined_at(StructDate.new(2018, 2, 15)) }
+    end
+  end
+
+  describe '#call' do
+    subject { matcher.call(other) }
+
+    context 'single argument extractor' do
+      let(:pattern) { 'Fear::Some(a : Integer)' }
+      let(:other) { Fear.some(42) }
+
+      it { is_expected.to eq(a: 42) }
+    end
+
+    context 'multiple arguments extractor' do
+      let(:pattern) { 'Date(2017, month, day)' }
+      let(:other) { Date.parse('2017-02-15') }
+
+      it { is_expected.to eq(month: 2, day: 15) }
+    end
+  end
+
+  describe '#failure_reason' do
+    subject { matcher.failure_reason(other) }
+
+    context 'no argument extractor' do
+      let(:pattern) { 'IsEven()' }
+
+      context 'defined' do
+        let(:other) { 42 }
+
+        it { is_expected.to eq(Fear.none) }
+      end
+
+      context 'not defined' do
+        let(:other) { 43 }
+
+        it { is_expected.to eq(Fear.some(<<-MSG.strip)) }
+Expected `43` to match:
+IsEven()
+^
+        MSG
+      end
+    end
+
+    context 'single argument extractor' do
+      let(:pattern) { 'Fear::Some(a : Integer)' }
+
+      context 'defined' do
+        let(:other) { Fear.some(42) }
+
+        it { is_expected.to eq(Fear.none) }
+      end
+
+      context 'not defined' do
+        let(:other) { Fear.some('42') }
+
+        it { is_expected.to eq(Fear.some(<<-MSG.strip)) }
+Expected `"42"` to match:
+Fear::Some(a : Integer)
+~~~~~~~~~~~~~~~^
+        MSG
+      end
+    end
+
+    context 'single argument extractor, array argument' do
+      let(:pattern) { 'Fear::Some([1, 2])' }
+
+      context 'defined' do
+        let(:other) { Fear.some([1, 2]) }
+
+        it { is_expected.to eq(Fear.none) }
+      end
+
+      context 'not defined' do
+        let(:other) { Fear.some([1, 1]) }
+
+        it { is_expected.to eq(Fear.some(<<-MSG.strip)) }
+Expected `1` to match:
+Fear::Some([1, 2])
+~~~~~~~~~~~~~~~^
+        MSG
+      end
+    end
+
+    context 'multiple arguments extractor' do
+      let(:pattern) { 'Date(year, 02, day)' }
+
+      context 'defined' do
+        let(:other) { Date.parse('2017-02-15') }
+
+        it { is_expected.to eq(Fear.none) }
+      end
+
+      context 'not defined' do
+        let(:other) { Date.parse('2017-04-15') }
+
+        it { is_expected.to eq(Fear.some(<<-MSG.strip)) }
+Expected `4` to match:
+Date(year, 02, day)
+~~~~~~~~~~~^
+        MSG
+      end
+    end
+  end
+end