fear 1.0.0 → 1.1.0

data/spec/fear/extractor/value_matcher_number_spec.rb

@@ -1,76 +1,78 @@
-RSpec.describe Fear::Extractor::ValueMatcher, 'Number' do
+# 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
+  describe "#defined_at?" do
     subject { matcher }
 
-    context 'Integer' do
-      let(:pattern) { '1' }
+    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') }
+      it { is_expected.not_to be_defined_at("1") }
     end
 
-    context 'Float' do
-      context 'against float' do
-        let(:pattern) { '1.2' }
+    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' }
+      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') }
+        it { is_expected.not_to be_defined_at("1") }
       end
     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/value_matcher_string_spec.rb

@@ -1,25 +1,27 @@
-RSpec.describe Fear::Extractor::ValueMatcher, 'String' do
+# 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
+  describe "#defined_at?" do
     subject { matcher }
 
-    context 'double quotas' do
+    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.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
+      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
+      context "escaped double quotes inside" do
         let(:pattern) { '"f\"oo"' }
 
         it { is_expected.to be_defined_at('f"oo') }
@@ -27,21 +29,21 @@ RSpec.describe Fear::Extractor::ValueMatcher, 'String' do
       end
     end
 
-    context 'single quotas' do
+    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.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
+      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
+      context "escaped single quotes inside" do
         let(:pattern) { "'f\\'oo'" }
 
         it { is_expected.to be_defined_at("f\\'oo") }
@@ -50,36 +52,36 @@ RSpec.describe Fear::Extractor::ValueMatcher, 'String' do
     end
   end
 
-  describe '#call' do
-    subject { matcher.call(other) }
+  describe "#call" do
+    subject { matcher.(other) }
 
     let(:pattern) { '"foo"' }
 
-    context 'defined' do
-      let(:other) { 'foo' }
+    context "defined" do
+      let(:other) { "foo" }
 
       it { is_expected.to eq({}) }
     end
   end
 
-  describe '#failure_reason' do
+  describe "#failure_reason" do
     subject { matcher.failure_reason(other) }
 
-    context 'match' do
-      let(:other) { 'foo' }
+    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' }
+    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"
-^
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `"bar"` to match:
+        "foo"
+        ^
       ERROR
     end
   end

data/spec/fear/extractor/value_matcher_symbol_spec.rb

@@ -1,68 +1,70 @@
-RSpec.describe Fear::Extractor::ValueMatcher, 'Symbol' do
+# 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
+  describe "#defined_at?" do
     subject { matcher }
 
-    context 'no quotas' do
-      let(:pattern) { ':foo' }
+    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("foo") }
       it { is_expected.not_to be_defined_at(:boo) }
       it { is_expected.not_to be_defined_at(2) }
     end
 
-    context 'double quotas' do
+    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("foo") }
       it { is_expected.not_to be_defined_at(:boo) }
       it { is_expected.not_to be_defined_at(2) }
     end
 
-    context 'single quotas' do
+    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("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) }
+  describe "#call" do
+    subject { matcher.(other) }
 
-    let(:pattern) { ':foo' }
+    let(:pattern) { ":foo" }
 
-    context 'defined' do
+    context "defined" do
       let(:other) { :foo }
 
       it { is_expected.to eq({}) }
     end
   end
 
-  describe '#failure_reason' do
+  describe "#failure_reason" do
     subject { matcher.failure_reason(other) }
 
-    context 'match' do
+    context "match" do
       let(:other) { :foo }
-      let(:pattern) { ':foo' }
+      let(:pattern) { ":foo" }
 
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'does not match' do
+    context "does not match" do
       let(:other) { :bar }
-      let(:pattern) { ':foo' }
+      let(:pattern) { ":foo" }
 
-      it { is_expected.to eq(Fear.some(<<-ERROR.strip)) }
-Expected `:bar` to match:
-:foo
-^
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `:bar` to match:
+        :foo
+        ^
       ERROR
     end
   end

data/spec/fear/extractor_api_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::ExtractorApi do
   def assert(value)
     expect(value).to eq(true)
@@ -17,97 +19,97 @@ RSpec.describe Fear::ExtractorApi do
     expect { yield }.not_to raise_error
   end
 
-  specify 'Array' do
-    assert(Fear['[]'] === [])
-    assert_not(Fear['[]'] === [1])
-    assert(Fear['[1]'] === [1])
-    assert_not(Fear['[1]'] === [1, 2])
-    assert_not(Fear['[1]'] === [2])
-    assert(Fear['[1, 2]'] === [1, 2])
-    assert_not(Fear['[1, 2]'] === [1, 3])
-    assert_not(Fear['[1, 2]'] === [1, 2, 4])
-    assert_not(Fear['[1, 2]'] === [1])
-    assert(Fear['[*]'] === [])
-    assert(Fear['[*]'] === [1, 2])
-    assert_not(Fear['[1, *]'] === [])
-    assert(Fear['[1, *]'] === [1])
-    assert(Fear['[1, *]'] === [1, 2])
-    assert(Fear['[1, *]'] === [1, 2, 3])
-    assert(Fear['[[1]]'] === [[1]])
-    assert(Fear['[[1],2]'] === [[1], 2])
-    assert(Fear['[[1],*]'] === [[1], 2])
-    assert(Fear['[[*],*]'] === [[1], 2])
-    assert_invalid_syntax  { Fear['[*, 2]'] }
-    assert_invalid_syntax  { Fear['[*, ]'] }
-    assert_invalid_syntax  { Fear['[1, *, ]'] }
-    assert_invalid_syntax  { Fear['[1, *, 2]'] }
-    assert_invalid_syntax  { Fear['[1, *, *]'] }
-    assert_invalid_syntax  { Fear['[*, *]'] }
-    assert(Fear['[a, b]'] === [1, 2])
-    assert_not(Fear['[a, b, c]'] === [1, 2])
-    assert(Fear['[a, b, _]'] === [1, 2, 3])
-    assert(Fear['[a, b, *c]'] === [1, 2])
-    assert_not(Fear['[a, b, c, *d]'] === [1, 2])
+  specify "Array" do
+    assert(Fear["[]"] === [])
+    assert_not(Fear["[]"] === [1])
+    assert(Fear["[1]"] === [1])
+    assert_not(Fear["[1]"] === [1, 2])
+    assert_not(Fear["[1]"] === [2])
+    assert(Fear["[1, 2]"] === [1, 2])
+    assert_not(Fear["[1, 2]"] === [1, 3])
+    assert_not(Fear["[1, 2]"] === [1, 2, 4])
+    assert_not(Fear["[1, 2]"] === [1])
+    assert(Fear["[*]"] === [])
+    assert(Fear["[*]"] === [1, 2])
+    assert_not(Fear["[1, *]"] === [])
+    assert(Fear["[1, *]"] === [1])
+    assert(Fear["[1, *]"] === [1, 2])
+    assert(Fear["[1, *]"] === [1, 2, 3])
+    assert(Fear["[[1]]"] === [[1]])
+    assert(Fear["[[1],2]"] === [[1], 2])
+    assert(Fear["[[1],*]"] === [[1], 2])
+    assert(Fear["[[*],*]"] === [[1], 2])
+    assert_invalid_syntax { Fear["[*, 2]"] }
+    assert_invalid_syntax { Fear["[*, ]"] }
+    assert_invalid_syntax { Fear["[1, *, ]"] }
+    assert_invalid_syntax { Fear["[1, *, 2]"] }
+    assert_invalid_syntax { Fear["[1, *, *]"] }
+    assert_invalid_syntax { Fear["[*, *]"] }
+    assert(Fear["[a, b]"] === [1, 2])
+    assert_not(Fear["[a, b, c]"] === [1, 2])
+    assert(Fear["[a, b, _]"] === [1, 2, 3])
+    assert(Fear["[a, b, *c]"] === [1, 2])
+    assert_not(Fear["[a, b, c, *d]"] === [1, 2])
   end
 
-  specify 'String' do
-    assert(Fear['"foo"'] === 'foo')
+  specify "String" do
+    assert(Fear['"foo"'] === "foo")
     assert(Fear['"f\"oo"'] === 'f"oo')
-    assert_not(Fear['"foo"'] === 'bar')
-    assert(Fear["'foo'"] === 'foo')
-    assert_not(Fear["'foo'"] === 'bar')
+    assert_not(Fear['"foo"'] === "bar")
+    assert(Fear["'foo'"] === "foo")
+    assert_not(Fear["'foo'"] === "bar")
   end
 
-  specify 'Symbol' do
+  specify "Symbol" do
     assert(Fear[':"foo"'] === :foo)
     assert(Fear[":'foo'"] === :foo)
-    assert(Fear[':foo'] === :foo)
-    assert_not(Fear[':foo'] === :bar)
+    assert(Fear[":foo"] === :foo)
+    assert_not(Fear[":foo"] === :bar)
   end
 
-  specify 'Boolean' do
-    assert(Fear['true'] === true)
-    assert(Fear['false'] === false)
-    assert_not(Fear['true'] === false)
-    assert_not(Fear['false'] === true)
+  specify "Boolean" do
+    assert(Fear["true"] === true)
+    assert(Fear["false"] === false)
+    assert_not(Fear["true"] === false)
+    assert_not(Fear["false"] === true)
   end
 
-  specify 'Nil' do
-    assert(Fear['nil'] === nil) # rubocop:disable Style/NilComparison
-    assert_not(Fear['nil'] === 42)
+  specify "Nil" do
+    assert(Fear["nil"] === nil) # rubocop:disable Style/NilComparison
+    assert_not(Fear["nil"] === 42)
   end
 
-  specify '_' do
-    assert(Fear['_'] === nil) # rubocop:disable Style/NilComparison
-    assert(Fear['_'] === true)
-    assert(Fear['_'] === false)
-    assert(Fear['_'] === 42)
-    assert(Fear['_'] === 'foo')
-    assert(Fear['_'] === [42])
+  specify "_" do
+    assert(Fear["_"] === nil) # rubocop:disable Style/NilComparison
+    assert(Fear["_"] === true)
+    assert(Fear["_"] === false)
+    assert(Fear["_"] === 42)
+    assert(Fear["_"] === "foo")
+    assert(Fear["_"] === [42])
   end
 
-  specify 'type matching' do
+  specify "type matching" do
     class Foo
       class Bar
       end
     end
 
-    assert(Fear['Integer'] === 3)
-    assert_not(Fear['Integer'] === '3')
-    assert(Fear['Numeric'] === 3)
-    assert(Fear['Foo::Bar'] === Foo::Bar.new)
-    assert(Fear['var : Integer'] === 3)
-    assert_not(Fear['var : Integer'] === '3')
+    assert(Fear["Integer"] === 3)
+    assert_not(Fear["Integer"] === "3")
+    assert(Fear["Numeric"] === 3)
+    assert(Fear["Foo::Bar"] === Foo::Bar.new)
+    assert(Fear["var : Integer"] === 3)
+    assert_not(Fear["var : Integer"] === "3")
   end
 
-  specify 'capture matcher' do
-    assert(Fear['array @ [head : Integer, *tail]'] === [1, 2])
-    assert_not(Fear['array @ [head : Integer, *tail]'] === ['1', 2])
+  specify "capture matcher" do
+    assert(Fear["array @ [head : Integer, *tail]"] === [1, 2])
+    assert_not(Fear["array @ [head : Integer, *tail]"] === ["1", 2])
   end
 
-  specify 'extractor' do
-    assert_valid_syntax { Fear['Foo(a, b : Integer)'] }
-    assert(Fear['Fear::Some(a : Integer)'] === Fear.some(42))
-    assert_not(Fear['Fear::Some(a : Integer)'] === Fear.some('foo'))
+  specify "extractor" do
+    assert_valid_syntax { Fear["Foo(a, b : Integer)"] }
+    assert(Fear["Fear::Some(a : Integer)"] === Fear.some(42))
+    assert_not(Fear["Fear::Some(a : Integer)"] === Fear.some("foo"))
   end
 end