fear 1.0.0 → 1.1.0

data/spec/fear/extractor/extractor_matcher_spec.rb

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

data/spec/fear/extractor/grammar_array_spec.rb

@@ -1,9 +1,11 @@
-RSpec.describe Fear::Extractor::Grammar, 'Array' do
+# 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]' }
+  context "non empty array" do
+    let(:pattern) { "[1, 2, 3, 4]" }
 
     it do
       first = matcher.head

data/spec/fear/extractor/identified_matcher_spec.rb

@@ -1,46 +1,48 @@
-RSpec.describe 'Fear::Extractor::IdentifiedMatcher' do
+# 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
+  describe "#defined_at?" do
     subject { matcher }
 
-    let(:pattern) { 'array @ [1, *tail]' }
+    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("foo") }
     it { is_expected.not_to be_defined_at([2, 1]) }
   end
 
-  describe '#call' do
-    subject { matcher.call(other) }
+  describe "#call" do
+    subject { matcher.(other) }
 
-    context 'defined' do
+    context "defined" do
       let(:other) { [1, 2] }
-      let(:pattern) { 'array @ [1, *tail]' }
+      let(:pattern) { "array @ [1, *tail]" }
 
       it { is_expected.to eq(array: [1, 2], tail: [2]) }
     end
   end
 
-  describe '#failure_reason' do
+  describe "#failure_reason" do
     subject { matcher.failure_reason(other) }
 
-    let(:pattern) { 'array @ [1, *tail]' }
+    let(:pattern) { "array @ [1, *tail]" }
 
-    context 'match integer' do
+    context "match integer" do
       let(:other) { [1, 2] }
 
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'does not match float' do
+    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]
-~~~~~~~~~^
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `2` to match:
+        array @ [1, *tail]
+        ~~~~~~~~~^
       ERROR
     end
   end

data/spec/fear/extractor/identifier_matcher_spec.rb

@@ -1,65 +1,67 @@
+# 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
+  describe "#defined_at?" do
     subject { matcher }
 
-    let(:pattern) { 'number' }
+    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("foo") }
     it { is_expected.to be_defined_at(1.2) }
-    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]' }
+    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']) }
+      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) }
+  describe "#call" do
+    subject { matcher.(other) }
 
-    let(:pattern) { '1.0' }
+    let(:pattern) { "1.0" }
 
-    context 'defined' do
+    context "defined" do
       let(:other) { 1 }
 
       it { is_expected.to eq({}) }
     end
   end
 
-  describe '#failure_reason' do
+  describe "#failure_reason" do
     subject { matcher.failure_reason(other) }
 
-    let(:pattern) { '1.0' }
+    let(:pattern) { "1.0" }
 
-    context 'match integer' do
+    context "match integer" do
       let(:other) { 1 }
-      let(:pattern) { '1' }
+      let(:pattern) { "1" }
 
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'match float' do
+    context "match float" do
       let(:other) { 1.0 }
-      let(:pattern) { '1' }
+      let(:pattern) { "1" }
 
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'does not match another integer' do
+    context "does not match another integer" do
       let(:other) { 2 }
-      let(:pattern) { '1' }
+      let(:pattern) { "1" }
 
-      it { is_expected.to eq(Fear.some(<<-ERROR.strip)) }
-Expected `2` to match:
-1
-^
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `2` to match:
+        1
+        ^
       ERROR
     end
   end

data/spec/fear/extractor/pattern_spec.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Extractor::Pattern do
-  describe '.new' do
-    context 'invalid syntax' do
-      subject { -> { described_class.new('[1, 2, 3') } }
+  describe ".new" do
+    context "invalid syntax" do
+      subject { -> { described_class.new("[1, 2, 3") } }
 
-      it 'shows where the error happens' do
+      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[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('~~~~~~~~^')
+          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])') }
+  describe "#failure_reason" do
+    let(:pattern) { described_class.new("Some([:err, 444])") }
 
-    context 'not defined' do
+    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])
-~~~~~~~~~~~~^
+      it { is_expected.to eq(<<~MSG.strip) }
+        Expected `445` to match:
+        Some([:err, 444])
+        ~~~~~~~~~~~~^
       MSG
     end
   end

data/spec/fear/extractor/typed_identifier_matcher_spec.rb

@@ -1,61 +1,63 @@
+# 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
+  describe "#defined_at?" do
     subject { matcher }
 
-    let(:pattern) { 'var : Integer' }
+    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("foo") }
     it { is_expected.not_to be_defined_at(1.2) }
 
-    context 'within array' do
-      let(:pattern) { '[1, n : String, 2]' }
+    context "within array" do
+      let(:pattern) { "[1, n : String, 2]" }
 
-      it { is_expected.to be_defined_at([1, 'foo', 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']) }
+      it { is_expected.not_to be_defined_at([1, "foo"]) }
     end
   end
 
-  describe '#call' do
-    subject { matcher.call(other) }
+  describe "#call" do
+    subject { matcher.(other) }
 
-    context 'defined' do
+    context "defined" do
       let(:other) { 1 }
-      let(:pattern) { 'var : Integer' }
+      let(:pattern) { "var : Integer" }
 
       it { is_expected.to eq(var: 1) }
     end
 
-    context 'defined within array' do
+    context "defined within array" do
       let(:other) { [4, 2, 1, 6] }
-      let(:pattern) { '[head : Integer, *tail]' }
+      let(:pattern) { "[head : Integer, *tail]" }
 
       it { is_expected.to eq(head: 4, tail: [2, 1, 6]) }
     end
   end
 
-  describe '#' do
+  describe "#" do
     subject { matcher.failure_reason(other) }
 
-    let(:pattern) { 'var : Integer' }
+    let(:pattern) { "var : Integer" }
 
-    context 'match integer' do
+    context "match integer" do
       let(:other) { 1 }
 
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'does not match float' do
+    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
-~~~~~~^
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `1.0` to match:
+        var : Integer
+        ~~~~~~^
       ERROR
     end
   end