fear 0.9.0 → 1.2.0

data/spec/fear/either/mixin_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::EitherPatternMatch do
+  context "Right" do
+    let(:matcher) do
+      described_class.new do |m|
+        m.right(:even?.to_proc) { |x| "#{x} is even" }
+        m.right(:odd?.to_proc) { |x| "#{x} is odd" }
+      end
+    end
+
+    it do
+      expect(matcher.(Fear.right(4))).to eq("4 is even")
+      expect(matcher.(Fear.right(3))).to eq("3 is odd")
+      expect do
+        matcher.(Fear.left(44))
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+
+  context "Left" do
+    let(:matcher) do
+      described_class.new do |m|
+        m.left(:even?.to_proc) { |x| "#{x} is even" }
+        m.left(:odd?.to_proc) { |x| "#{x} is odd" }
+      end
+    end
+
+    it do
+      expect(matcher.(Fear.left(4))).to eq("4 is even")
+      expect(matcher.(Fear.left(3))).to eq("3 is odd")
+      expect do
+        matcher.(Fear.right(44))
+      end.to raise_error(Fear::MatchError)
+    end
+  end
+end

data/spec/fear/either_pattern_matching_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Either do
+  describe "pattern matching" do
+    subject do
+      case value
+      in Fear::Right[Integer => int]
+        "right of #{int}"
+      in Fear::Left[Integer => int]
+        "left of #{int}"
+      else
+        "something else"
+      end
+    end
+
+    context "when value is right of integer" do
+      let(:value) { Fear.right(42) }
+
+      it { is_expected.to eq("right of 42") }
+    end
+
+    context "when value is left of integer" do
+      let(:value) { Fear.left(42) }
+
+      it { is_expected.to eq("left of 42") }
+    end
+  end
+end

data/spec/fear/extractor/array_matcher_spec.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+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.(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,153 @@
+# frozen_string_literal: true
+
+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.(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