fear 1.0.0 → 2.0.0

data/spec/fear/extractor/array_matcher_spec.rb

@@ -1,228 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

data/spec/fear/extractor/grammar_array_spec.rb

@@ -1,23 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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