fear 0.11.0 → 1.0.0

data/spec/fear/extractor/grammar_array_spec.rb

@@ -0,0 +1,23 @@
+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,47 @@
+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.call(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,66 @@
+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.call(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,32 @@
+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,62 @@
+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.call(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,77 @@
+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.call(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,86 @@
+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.call(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,69 @@
+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.call(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