fear 1.0.0 → 1.1.0

data/lib/fear/success.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   class Success
     include Try

data/lib/fear/success_pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @api private
   class SuccessPatternMatch < Fear::TryPatternMatch

data/lib/fear/try.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # The +Try+ represents a computation that may either result
   # in an exception, or return a successfully computed value. Instances of +Try+,

data/lib/fear/try_api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   module TryApi
     # Constructs a +Try+ using the block. This

data/lib/fear/try_pattern_match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # Try pattern matcher
   #

data/lib/fear/unit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # Represents lack of value. It's typically returned when function completed without a value.
   #
@@ -17,12 +19,14 @@ module Fear
   Unit = Object.new.tap do |unit|
     # @return [String]
     def unit.to_s
-      '#<Fear::Unit>'
+      "#<Fear::Unit>"
     end
 
     # @return [String]
     def unit.inspect
-      '#<Fear::Unit>'
+      "#<Fear::Unit>"
     end
   end.freeze
+
+  public_constant :Unit
 end

data/lib/fear/utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @private
   module Utils
@@ -20,13 +22,13 @@ module Fear
 
       def assert_type!(value, *types)
         if types.none? { |type| value.is_a?(type) }
-          raise TypeError, "expected `#{value.inspect}` to be of #{types.join(', ')} class"
+          raise TypeError, "expected `#{value.inspect}` to be of #{types.join(", ")} class"
         end
       end
 
       def return_or_call_proc(value)
         if value.respond_to?(:call)
-          value.call
+          value.()
         else
           value
         end

data/lib/fear/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module Fear
-  VERSION = '1.0.0'.freeze
+  VERSION = "1.1.0"
+  public_constant :VERSION
 end

data/spec/fear/done_spec.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Unit do
-  describe '#to_s' do
+  describe "#to_s" do
     subject { described_class.to_s }
 
-    it { is_expected.to eq('#<Fear::Unit>') }
+    it { is_expected.to eq("#<Fear::Unit>") }
   end
 
-  describe '#inspect' do
+  describe "#inspect" do
     subject { described_class.inspect }
 
-    it { is_expected.to eq('#<Fear::Unit>') }
+    it { is_expected.to eq("#<Fear::Unit>") }
   end
 
-  describe '#==' do
+  describe "#==" do
     it { is_expected.to eq(described_class) }
   end
 end

data/spec/fear/either/mixin_spec.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Either::Mixin do
   include Fear::Either::Mixin
 
-  describe 'Left()' do
+  describe "Left()" do
     subject { Left(42) }
 
     it { is_expected.to eq(Fear::Left.new(42)) }
   end
 
-  describe 'Right()' do
+  describe "Right()" do
     subject { Right(42) }
 
     it { is_expected.to eq(Fear::Right.new(42)) }

data/spec/fear/either_pattern_match_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::EitherPatternMatch do
-  context 'Right' do
+  context "Right" do
     let(:matcher) do
       described_class.new do |m|
         m.right(:even?.to_proc) { |x| "#{x} is even" }
@@ -8,15 +10,15 @@ RSpec.describe Fear::EitherPatternMatch do
     end
 
     it do
-      expect(matcher.call(Fear.right(4))).to eq('4 is even')
-      expect(matcher.call(Fear.right(3))).to eq('3 is odd')
+      expect(matcher.(Fear.right(4))).to eq("4 is even")
+      expect(matcher.(Fear.right(3))).to eq("3 is odd")
       expect do
-        matcher.call(Fear.left(44))
+        matcher.(Fear.left(44))
       end.to raise_error(Fear::MatchError)
     end
   end
 
-  context 'Left' do
+  context "Left" do
     let(:matcher) do
       described_class.new do |m|
         m.left(:even?.to_proc) { |x| "#{x} is even" }
@@ -25,10 +27,10 @@ RSpec.describe Fear::EitherPatternMatch do
     end
 
     it do
-      expect(matcher.call(Fear.left(4))).to eq('4 is even')
-      expect(matcher.call(Fear.left(3))).to eq('3 is odd')
+      expect(matcher.(Fear.left(4))).to eq("4 is even")
+      expect(matcher.(Fear.left(3))).to eq("3 is odd")
       expect do
-        matcher.call(Fear.right(44))
+        matcher.(Fear.right(44))
       end.to raise_error(Fear::MatchError)
     end
   end

data/spec/fear/extractor/array_matcher_spec.rb

@@ -1,43 +1,45 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Extractor::ArrayMatcher 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 'empty array' do
-      let(:pattern) { '[]' }
+    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) { '[*]' }
+    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]' }
+    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]' }
+    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]' }
+      context "identifier" do
+        let(:pattern) { "[var]" }
 
         it { is_expected.not_to be_defined_at([]) }
         it { is_expected.to be_defined_at([1]) }
@@ -45,8 +47,8 @@ RSpec.describe Fear::Extractor::ArrayMatcher do
       end
     end
 
-    context 'two elements array with nested matcher' do
-      let(:pattern) { '[[1, *], 1]' }
+    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]) }
@@ -55,8 +57,8 @@ RSpec.describe Fear::Extractor::ArrayMatcher do
       it { is_expected.not_to be_defined_at([2, 1]) }
     end
 
-    context 'one element array with splat' do
-      let(:pattern) { '[1, *]' }
+    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]) }
@@ -65,8 +67,8 @@ RSpec.describe Fear::Extractor::ArrayMatcher do
       it { is_expected.not_to be_defined_at([2, 1]) }
     end
 
-    context 'one element array with named splat' do
-      let(:pattern) { '[1, *var]' }
+    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]) }
@@ -75,9 +77,9 @@ RSpec.describe Fear::Extractor::ArrayMatcher do
       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]' }
+    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]) }
@@ -87,16 +89,16 @@ RSpec.describe Fear::Extractor::ArrayMatcher do
         it { is_expected.not_to be_defined_at([2]) }
       end
 
-      context 'head and tail' do
-        let(:pattern) { '[head, *tail]' }
+      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 ]' }
+    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]) }
@@ -106,8 +108,8 @@ RSpec.describe Fear::Extractor::ArrayMatcher do
       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]' }
+      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]) }
@@ -119,109 +121,109 @@ RSpec.describe Fear::Extractor::ArrayMatcher do
     end
   end
 
-  describe '#call' do
-    subject { matcher.call(other) }
+  describe "#call" do
+    subject { matcher.(other) }
 
-    context 'on the same array' do
+    context "on the same array" do
       let(:other) { [1] }
-      let(:pattern) { '[1]' }
+      let(:pattern) { "[1]" }
 
       it { is_expected.to eq({}) }
     end
 
-    context 'with splat on another array' do
+    context "with splat on another array" do
       let(:other) { [2, 1] }
-      let(:pattern) { '[2, *]' }
+      let(:pattern) { "[2, *]" }
 
       it { is_expected.to eq({}) }
     end
 
-    context 'with identifier at the middle of an array' do
+    context "with identifier at the middle of an array" do
       let(:other) { [2, 1, 3] }
-      let(:pattern) { '[2, var, 3]' }
+      let(:pattern) { "[2, var, 3]" }
 
       it { is_expected.to eq(var: 1) }
     end
 
-    context 'with identifier at the end of an array' do
+    context "with identifier at the end of an array" do
       let(:other) { [2, 1, 3] }
-      let(:pattern) { '[2, 1, var]' }
+      let(:pattern) { "[2, 1, var]" }
 
       it { is_expected.to eq(var: 3) }
     end
 
-    context 'with named splat matching all the array' do
+    context "with named splat matching all the array" do
       let(:other) { [2, 1, 3, 4] }
-      let(:pattern) { '[*var]' }
+      let(:pattern) { "[*var]" }
 
       it { is_expected.to eq(var: [2, 1, 3, 4]) }
     end
 
-    context 'with named splat matching tail of an array' do
+    context "with named splat matching tail of an array" do
       let(:other) { [2, 1, 3, 4] }
-      let(:pattern) { '[2, 1, *var]' }
+      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
+    context "with named splat at the end of an array" do
       let(:other) { [2, 1] }
-      let(:pattern) { '[2, 1, *var]' }
+      let(:pattern) { "[2, 1, *var]" }
 
       it { is_expected.to eq(var: []) }
     end
 
-    context 'with several identifiers in an array' do
+    context "with several identifiers in an array" do
       let(:other) { [2, 1, 3] }
-      let(:pattern) { '[a, 1, b]' }
+      let(:pattern) { "[a, 1, b]" }
 
       it { is_expected.to eq(a: 2, b: 3) }
     end
 
-    context 'head and tail' do
+    context "head and tail" do
       let(:other) { [2, 1, 3] }
-      let(:pattern) { '[head, *tail]' }
+      let(:pattern) { "[head, *tail]" }
 
       it { is_expected.to eq(head: 2, tail: [1, 3]) }
     end
 
-    context 'ignore head, capture tail' do
+    context "ignore head, capture tail" do
       let(:other) { [2, 1, 3] }
-      let(:pattern) { '[_, *tail]' }
+      let(:pattern) { "[_, *tail]" }
 
       it { is_expected.to eq(tail: [1, 3]) }
     end
   end
 
-  describe '#failure_reason' do
+  describe "#failure_reason" do
     subject { matcher.failure_reason(other) }
 
-    context 'on the same array' do
+    context "on the same array" do
       let(:other) { [1] }
-      let(:pattern) { '[1]' }
+      let(:pattern) { "[1]" }
 
       it { is_expected.to eq(Fear.none) }
     end
 
-    context 'on another array' do
+    context "on another array" do
       let(:other) { [2, 1] }
-      let(:pattern) { '[2, 2]' }
+      let(:pattern) { "[2, 2]" }
 
-      it { is_expected.to eq(Fear.some(<<-ERROR.strip)) }
-Expected `1` to match:
-[2, 2]
-~~~~^
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `1` to match:
+        [2, 2]
+        ~~~~^
       ERROR
     end
 
-    context 'element type mismatch' do
+    context "element type mismatch" do
       let(:other) { [2, 1] }
-      let(:pattern) { '[[2], 1]' }
+      let(:pattern) { "[[2], 1]" }
 
-      it { is_expected.to eq(Fear.some(<<-ERROR.strip)) }
-Expected `2` to match:
-[[2], 1]
-~~^
+      it { is_expected.to eq(Fear.some(<<~ERROR.strip)) }
+        Expected `2` to match:
+        [[2], 1]
+        ~~^
       ERROR
     end
   end