fear 0.9.0 → 1.2.0

data/spec/fear/extractor/grammar_array_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor::Grammar, "Array" do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  context "non empty array" do
+    let(:pattern) { "[1, 2, 3, 4]" }
+
+    it do
+      first = matcher.head
+      rest_after_first = matcher.tail
+
+      expect(first).to be_kind_of(Fear::Extractor::ArrayHeadMatcher)
+      expect(first.matcher.value).to eq(1)
+      expect(rest_after_first).to be_kind_of(Fear::Extractor::ArrayMatcher)
+
+      second = rest_after_first.head
+      rest_after_second = rest_after_first.tail
+      expect(second).to be_kind_of(Fear::Extractor::ArrayHeadMatcher)
+      expect(second.matcher.value).to eq(2)
+      expect(rest_after_second).to be_kind_of(Fear::Extractor::ArrayMatcher)
+    end
+  end
+end

data/spec/fear/extractor/identified_matcher_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe "Fear::Extractor::IdentifiedMatcher" do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe "#defined_at?" do
+    subject { matcher }
+
+    let(:pattern) { "array @ [1, *tail]" }
+
+    it { is_expected.to be_defined_at([1, 2]) }
+    it { is_expected.not_to be_defined_at("foo") }
+    it { is_expected.not_to be_defined_at([2, 1]) }
+  end
+
+  describe "#call" do
+    subject { matcher.(other) }
+
+    context "defined" do
+      let(:other) { [1, 2] }
+      let(:pattern) { "array @ [1, *tail]" }
+
+      it { is_expected.to eq(array: [1, 2], tail: [2]) }
+    end
+  end
+
+  describe "#failure_reason" do
+    subject { matcher.failure_reason(other) }
+
+    let(:pattern) { "array @ [1, *tail]" }
+
+    context "match integer" do
+      let(:other) { [1, 2] }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "does not match float" do
+      let(:other) { [2, 2] }
+
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `2` to match:
+        array @ [1, *tail]
+        ~~~~~~~~~^
+      ERROR
+    end
+  end
+end

data/spec/fear/extractor/identifier_matcher_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor::IdentifierMatcher do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe "#defined_at?" do
+    subject { matcher }
+
+    let(:pattern) { "number" }
+
+    it { is_expected.to be_defined_at(1) }
+    it { is_expected.to be_defined_at("foo") }
+    it { is_expected.to be_defined_at(1.2) }
+    it { is_expected.to be_defined_at([1, "2"]) }
+
+    context "within array" do
+      let(:pattern) { "[1, n, 2]" }
+
+      it { is_expected.to be_defined_at([1, 2, 2]) }
+      it { is_expected.to be_defined_at([1, "foo", 2]) }
+      it { is_expected.not_to be_defined_at([1, "foo"]) }
+    end
+  end
+
+  describe "#call" do
+    subject { matcher.(other) }
+
+    let(:pattern) { "1.0" }
+
+    context "defined" do
+      let(:other) { 1 }
+
+      it { is_expected.to eq({}) }
+    end
+  end
+
+  describe "#failure_reason" do
+    subject { matcher.failure_reason(other) }
+
+    let(:pattern) { "1.0" }
+
+    context "match integer" do
+      let(:other) { 1 }
+      let(:pattern) { "1" }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "match float" do
+      let(:other) { 1.0 }
+      let(:pattern) { "1" }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "does not match another integer" do
+      let(:other) { 2 }
+      let(:pattern) { "1" }
+
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `2` to match:
+        1
+        ^
+      ERROR
+    end
+  end
+end

data/spec/fear/extractor/pattern_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor::Pattern do
+  describe ".new" do
+    context "invalid syntax" do
+      subject { -> { described_class.new("[1, 2, 3") } }
+
+      it "shows where the error happens" do
+        is_expected.to raise_error(Fear::PatternSyntaxError) { |error|
+          lines = error.message.split("\n")
+          expect(lines[0]).to start_with("Expected one of")
+            .and(end_with("at line 1, column 9 (byte 9):"))
+
+          expect(lines[1]).to eq("[1, 2, 3")
+          expect(lines[2]).to eq("~~~~~~~~^")
+        }
+      end
+    end
+  end
+
+  describe "#failure_reason" do
+    let(:pattern) { described_class.new("Some([:err, 444])") }
+
+    context "not defined" do
+      subject { pattern.failure_reason(Fear.some([:err, 445])) }
+
+      it { is_expected.to eq(<<~MSG.strip) }
+        Expected `445` to match:
+        Some([:err, 444])
+        ~~~~~~~~~~~~^
+      MSG
+    end
+  end
+end

data/spec/fear/extractor/typed_identifier_matcher_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor::TypedIdentifierMatcher do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe "#defined_at?" do
+    subject { matcher }
+
+    let(:pattern) { "var : Integer" }
+
+    it { is_expected.to be_defined_at(1) }
+    it { is_expected.not_to be_defined_at("foo") }
+    it { is_expected.not_to be_defined_at(1.2) }
+
+    context "within array" do
+      let(:pattern) { "[1, n : String, 2]" }
+
+      it { is_expected.to be_defined_at([1, "foo", 2]) }
+      it { is_expected.not_to be_defined_at([1, 2, 2]) }
+      it { is_expected.not_to be_defined_at([1, "foo"]) }
+    end
+  end
+
+  describe "#call" do
+    subject { matcher.(other) }
+
+    context "defined" do
+      let(:other) { 1 }
+      let(:pattern) { "var : Integer" }
+
+      it { is_expected.to eq(var: 1) }
+    end
+
+    context "defined within array" do
+      let(:other) { [4, 2, 1, 6] }
+      let(:pattern) { "[head : Integer, *tail]" }
+
+      it { is_expected.to eq(head: 4, tail: [2, 1, 6]) }
+    end
+  end
+
+  describe "#" do
+    subject { matcher.failure_reason(other) }
+
+    let(:pattern) { "var : Integer" }
+
+    context "match integer" do
+      let(:other) { 1 }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "does not match float" do
+      let(:other) { 1.0 }
+
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `1.0` to match:
+        var : Integer
+        ~~~~~~^
+      ERROR
+    end
+  end
+end

data/spec/fear/extractor/value_matcher_number_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor::ValueMatcher, "Number" do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe "#defined_at?" do
+    subject { matcher }
+
+    context "Integer" do
+      let(:pattern) { "1" }
+
+      it { is_expected.to be_defined_at(1) }
+      it { is_expected.to be_defined_at(1.0) }
+      it { is_expected.not_to be_defined_at(2) }
+      it { is_expected.not_to be_defined_at("1") }
+    end
+
+    context "Float" do
+      context "against float" do
+        let(:pattern) { "1.2" }
+
+        it { is_expected.to be_defined_at(1.2) }
+        it { is_expected.not_to be_defined_at(1.3) }
+      end
+
+      context "against integer" do
+        let(:pattern) { "1.0" }
+
+        it { is_expected.to be_defined_at(1) }
+        it { is_expected.not_to be_defined_at(2) }
+        it { is_expected.not_to be_defined_at("1") }
+      end
+    end
+  end
+
+  describe "#call" do
+    subject { matcher.(other) }
+
+    let(:pattern) { "1.0" }
+
+    context "defined" do
+      let(:other) { 1 }
+
+      it { is_expected.to eq({}) }
+    end
+  end
+
+  describe "#failure_reason" do
+    subject { matcher.failure_reason(other) }
+
+    let(:pattern) { "1.0" }
+
+    context "match integer" do
+      let(:other) { 1 }
+      let(:pattern) { "1" }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "match float" do
+      let(:other) { 1.0 }
+      let(:pattern) { "1" }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "does not match another integer" do
+      let(:other) { 2 }
+      let(:pattern) { "1" }
+
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `2` to match:
+        1
+        ^
+      ERROR
+    end
+  end
+end

data/spec/fear/extractor/value_matcher_string_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor::ValueMatcher, "String" do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe "#defined_at?" do
+    subject { matcher }
+
+    context "double quotas" do
+      let(:pattern) { %("foo") }
+
+      it { is_expected.to be_defined_at("foo") }
+      it { is_expected.not_to be_defined_at("boo") }
+      it { is_expected.not_to be_defined_at(2) }
+
+      context "single quotes inside" do
+        let(:pattern) { %("f'o'o") }
+
+        it { is_expected.to be_defined_at(%(f'o'o)) }
+        it { is_expected.not_to be_defined_at(%(f"o"o)) }
+      end
+
+      context "escaped double quotes inside" do
+        let(:pattern) { '"f\"oo"' }
+
+        it { is_expected.to be_defined_at('f"oo') }
+        it { is_expected.not_to be_defined_at("f'oo") }
+      end
+    end
+
+    context "single quotas" do
+      let(:pattern) { %('foo') }
+
+      it { is_expected.to be_defined_at("foo") }
+      it { is_expected.not_to be_defined_at("boo") }
+      it { is_expected.not_to be_defined_at(2) }
+
+      context "double quotes inside" do
+        let(:pattern) { %('f"o"o') }
+
+        it { is_expected.to be_defined_at(%(f"o"o)) }
+        it { is_expected.not_to be_defined_at(%(f'o'o)) }
+      end
+
+      context "escaped single quotes inside" do
+        let(:pattern) { "'f\\'oo'" }
+
+        it { is_expected.to be_defined_at("f\\'oo") }
+        it { is_expected.not_to be_defined_at("f'oo") }
+      end
+    end
+  end
+
+  describe "#call" do
+    subject { matcher.(other) }
+
+    let(:pattern) { '"foo"' }
+
+    context "defined" do
+      let(:other) { "foo" }
+
+      it { is_expected.to eq({}) }
+    end
+  end
+
+  describe "#failure_reason" do
+    subject { matcher.failure_reason(other) }
+
+    context "match" do
+      let(:other) { "foo" }
+      let(:pattern) { '"foo"' }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "does not match" do
+      let(:other) { "bar" }
+      let(:pattern) { '"foo"' }
+
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `"bar"` to match:
+        "foo"
+        ^
+      ERROR
+    end
+  end
+end

data/spec/fear/extractor/value_matcher_symbol_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Extractor::ValueMatcher, "Symbol" do
+  let(:parser) { Fear::Extractor::GrammarParser.new }
+  let(:matcher) { parser.parse(pattern).to_matcher }
+
+  describe "#defined_at?" do
+    subject { matcher }
+
+    context "no quotas" do
+      let(:pattern) { ":foo" }
+
+      it { is_expected.to be_defined_at(:foo) }
+      it { is_expected.not_to be_defined_at("foo") }
+      it { is_expected.not_to be_defined_at(:boo) }
+      it { is_expected.not_to be_defined_at(2) }
+    end
+
+    context "double quotas" do
+      let(:pattern) { %(:"foo") }
+
+      it { is_expected.to be_defined_at(:foo) }
+      it { is_expected.not_to be_defined_at("foo") }
+      it { is_expected.not_to be_defined_at(:boo) }
+      it { is_expected.not_to be_defined_at(2) }
+    end
+
+    context "single quotas" do
+      let(:pattern) { %(:'foo') }
+
+      it { is_expected.to be_defined_at(:foo) }
+      it { is_expected.not_to be_defined_at("foo") }
+      it { is_expected.not_to be_defined_at(:boo) }
+      it { is_expected.not_to be_defined_at(2) }
+    end
+  end
+
+  describe "#call" do
+    subject { matcher.(other) }
+
+    let(:pattern) { ":foo" }
+
+    context "defined" do
+      let(:other) { :foo }
+
+      it { is_expected.to eq({}) }
+    end
+  end
+
+  describe "#failure_reason" do
+    subject { matcher.failure_reason(other) }
+
+    context "match" do
+      let(:other) { :foo }
+      let(:pattern) { ":foo" }
+
+      it { is_expected.to eq(Fear.none) }
+    end
+
+    context "does not match" do
+      let(:other) { :bar }
+      let(:pattern) { ":foo" }
+
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `:bar` to match:
+        :foo
+        ^
+      ERROR
+    end
+  end
+end