fear 1.0.0 → 1.1.0

data/spec/fear/right_biased/left.rb

@@ -1,85 +1,87 @@
+# frozen_string_literal: true
+
 RSpec.shared_examples Fear::RightBiased::Left do
-  describe '#include?' do
+  describe "#include?" do
     subject { left }
-    it { is_expected.not_to include('value') }
+    it { is_expected.not_to include("value") }
   end
 
-  describe '#get_or_else' do
-    context 'with block' do
-      subject { left.get_or_else { 'default' } }
+  describe "#get_or_else" do
+    context "with block" do
+      subject { left.get_or_else { "default" } }
 
-      it 'returns default value' do
-        is_expected.to eq('default')
+      it "returns default value" do
+        is_expected.to eq("default")
       end
     end
 
-    context 'with default argument' do
-      subject { left.get_or_else('default') }
+    context "with default argument" do
+      subject { left.get_or_else("default") }
 
-      it 'returns default value' do
-        is_expected.to eq('default')
+      it "returns default value" do
+        is_expected.to eq("default")
       end
     end
 
-    context 'with false argument' do
+    context "with false argument" do
       subject { left.get_or_else(false) }
 
-      it 'returns default value' do
+      it "returns default value" do
         is_expected.to eq(false)
       end
     end
 
-    context 'with nil argument' do
+    context "with nil argument" do
       subject { left.get_or_else(nil) }
 
-      it 'returns default value' do
+      it "returns default value" do
         is_expected.to eq(nil)
       end
     end
   end
 
-  describe '#each' do
+  describe "#each" do
     subject do
       proc do |block|
         expect(left.each(&block)).to eq(left)
       end
     end
 
-    it 'does not call the block' do
+    it "does not call the block" do
       is_expected.not_to yield_control
     end
   end
 
-  describe '#map' do
+  describe "#map" do
     subject { left.map(&:length) }
 
-    it 'returns self' do
+    it "returns self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#flat_map' do
+  describe "#flat_map" do
     subject { left.flat_map(&:length) }
 
-    it 'returns self' do
+    it "returns self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#to_option' do
+  describe "#to_option" do
     subject { left.to_option }
     it { is_expected.to eq(Fear::None) }
   end
 
-  describe '#any?' do
-    subject { left.any? { |v| v == 'value' } }
+  describe "#any?" do
+    subject { left.any? { |v| v == "value" } }
     it { is_expected.to eq(false) }
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === left }
 
-    context 'the same object' do
+    context "the same object" do
       let(:match) { left }
       it { is_expected.to eq(true) }
     end

data/spec/fear/right_biased/right.rb

@@ -1,141 +1,143 @@
+# frozen_string_literal: true
+
 RSpec.shared_examples Fear::RightBiased::Right do
-  describe '#include?' do
-    context 'contains value' do
-      subject { right.include?('value') }
+  describe "#include?" do
+    context "contains value" do
+      subject { right.include?("value") }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not contain value' do
-      subject { right.include?('another value') }
+    context "does not contain value" do
+      subject { right.include?("another value") }
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '#get_or_else' do
-    context 'with block' do
-      subject { right.get_or_else { 'default' } }
+  describe "#get_or_else" do
+    context "with block" do
+      subject { right.get_or_else { "default" } }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
 
-    context 'with default argument' do
-      subject { right.get_or_else('default') }
+    context "with default argument" do
+      subject { right.get_or_else("default") }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
 
-    context 'with false argument' do
+    context "with false argument" do
       subject { right.get_or_else(false) }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
 
-    context 'with nil argument' do
+    context "with nil argument" do
       subject { right.get_or_else(nil) }
 
-      it 'returns value' do
-        is_expected.to eq('value')
+      it "returns value" do
+        is_expected.to eq("value")
       end
     end
   end
 
-  describe '#each' do
+  describe "#each" do
     subject do
       proc do |block|
         expect(right.each(&block)).to eq(right)
       end
     end
 
-    it 'calls the block with value' do
-      is_expected.to yield_with_args('value')
+    it "calls the block with value" do
+      is_expected.to yield_with_args("value")
     end
   end
 
-  describe '#or_else' do
-    it 'does not call block' do
+  describe "#or_else" do
+    it "does not call block" do
       expect { |probe| right.or_else(&probe) }.not_to yield_control
     end
 
-    it 'returns the same object' do
+    it "returns the same object" do
       expect(right.or_else { 42 }).to eql(right)
     end
   end
 
-  describe '#map' do
+  describe "#map" do
     subject { right.map(&:length) }
 
-    it 'perform transformation' do
+    it "perform transformation" do
       is_expected.to eq(described_class.new(5))
     end
   end
 
-  describe '#flat_map' do
-    context 'block returns neither left, nor right' do
+  describe "#flat_map" do
+    context "block returns neither left, nor right" do
       subject { proc { right.flat_map { 42 } } }
 
-      it 'fails with TypeError' do
+      it "fails with TypeError" do
         is_expected.to raise_error(TypeError)
       end
     end
 
-    context 'block returns RightBiased' do
+    context "block returns RightBiased" do
       subject { right.flat_map { |e| described_class.new("Result: #{e}") } }
 
-      it 'maps to block result' do
-        is_expected.to eq(described_class.new('Result: value'))
+      it "maps to block result" do
+        is_expected.to eq(described_class.new("Result: value"))
       end
     end
   end
 
-  describe '#to_option' do
+  describe "#to_option" do
     subject { right.to_option }
-    it { is_expected.to eq(Fear::Some.new('value')) }
+    it { is_expected.to eq(Fear::Some.new("value")) }
   end
 
-  describe '#any?' do
+  describe "#any?" do
     subject { right.any?(&predicate) }
 
-    context 'matches predicate' do
-      let(:predicate) { ->(v) { v == 'value' } }
+    context "matches predicate" do
+      let(:predicate) { ->(v) { v == "value" } }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not match predicate' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "does not match predicate" do
+      let(:predicate) { ->(v) { v != "value" } }
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === right }
 
-    context 'matches erectly' do
-      let(:match) { described_class.new('value') }
+    context "matches erectly" do
+      let(:match) { described_class.new("value") }
       it { is_expected.to eq(true) }
     end
 
-    context 'the same object' do
+    context "the same object" do
       let(:match) { right }
       it { is_expected.to eq(true) }
     end
 
-    context 'value does not match' do
-      let(:match) { described_class.new('error') }
+    context "value does not match" do
+      let(:match) { described_class.new("error") }
       it { is_expected.to eq(false) }
     end
 
-    context 'matches by class' do
+    context "matches by class" do
       let(:match) { described_class.new(String) }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not matches by class' do
+    context "does not matches by class" do
       let(:match) { described_class.new(Integer) }
       it { is_expected.to eq(false) }
     end

data/spec/fear/right_spec.rb

@@ -1,76 +1,78 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Right do
   it_behaves_like Fear::RightBiased::Right do
-    let(:right) { Fear.right('value') }
+    let(:right) { Fear.right("value") }
   end
 
-  let(:right) { Fear.right('value') }
+  let(:right) { Fear.right("value") }
 
-  describe '#right?' do
+  describe "#right?" do
     subject { right }
     it { is_expected.to be_right }
   end
 
-  describe '#left?' do
+  describe "#left?" do
     subject { right }
     it { is_expected.not_to be_left }
   end
 
-  describe '#select_or_else' do
+  describe "#select_or_else" do
     subject { right.select_or_else(default, &predicate) }
 
-    context 'predicate evaluates to true' do
-      let(:predicate) { ->(v) { v == 'value' } }
+    context "predicate evaluates to true" do
+      let(:predicate) { ->(v) { v == "value" } }
       let(:default) { -1 }
       it { is_expected.to eq(right) }
     end
 
-    context 'predicate evaluates to false and default is a proc' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "predicate evaluates to false and default is a proc" do
+      let(:predicate) { ->(v) { v != "value" } }
       let(:default) { -> { -1 } }
       it { is_expected.to eq(Fear.left(-1)) }
     end
 
-    context 'predicate evaluates to false and default is not a proc' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "predicate evaluates to false and default is not a proc" do
+      let(:predicate) { ->(v) { v != "value" } }
       let(:default) { -1 }
       it { is_expected.to eq(Fear.left(-1)) }
     end
   end
 
-  describe '#select' do
+  describe "#select" do
     subject { right.select(&predicate) }
 
-    context 'predicate evaluates to true' do
-      let(:predicate) { ->(v) { v == 'value' } }
+    context "predicate evaluates to true" do
+      let(:predicate) { ->(v) { v == "value" } }
       it { is_expected.to eq(right) }
     end
 
-    context 'predicate evaluates to false' do
-      let(:predicate) { ->(v) { v != 'value' } }
-      it { is_expected.to eq(Fear.left('value')) }
+    context "predicate evaluates to false" do
+      let(:predicate) { ->(v) { v != "value" } }
+      it { is_expected.to eq(Fear.left("value")) }
     end
   end
 
-  describe '#reject' do
+  describe "#reject" do
     subject { right.reject(&predicate) }
 
-    context 'predicate evaluates to true' do
-      let(:predicate) { ->(v) { v == 'value' } }
-      it { is_expected.to eq(Fear.left('value')) }
+    context "predicate evaluates to true" do
+      let(:predicate) { ->(v) { v == "value" } }
+      it { is_expected.to eq(Fear.left("value")) }
     end
 
-    context 'predicate evaluates to false' do
-      let(:predicate) { ->(v) { v != 'value' } }
+    context "predicate evaluates to false" do
+      let(:predicate) { ->(v) { v != "value" } }
       it { is_expected.to eq(right) }
     end
   end
 
-  describe '#swap' do
+  describe "#swap" do
     subject { right.swap }
-    it { is_expected.to eq(Fear.left('value')) }
+    it { is_expected.to eq(Fear.left("value")) }
   end
 
-  describe '#reduce' do
+  describe "#reduce" do
     subject do
       right.reduce(
         ->(left) { "Left: #{left}" },
@@ -78,45 +80,45 @@ RSpec.describe Fear::Right do
       )
     end
 
-    it { is_expected.to eq('Right: value') }
+    it { is_expected.to eq("Right: value") }
   end
 
-  describe '#join_right' do
-    context 'value is Either' do
+  describe "#join_right" do
+    context "value is Either" do
       subject { described_class.new(value).join_right }
-      let(:value) { Fear.left('error') }
+      let(:value) { Fear.left("error") }
 
-      it 'returns value' do
+      it "returns value" do
         is_expected.to eq(value)
       end
     end
 
-    context 'value is not Either' do
-      subject { proc { described_class.new('35').join_right } }
+    context "value is not Either" do
+      subject { proc { described_class.new("35").join_right } }
 
-      it 'fails with type error' do
+      it "fails with type error" do
         is_expected.to raise_error(TypeError)
       end
     end
   end
 
-  describe '#join_left' do
-    context 'value is Either' do
+  describe "#join_left" do
+    context "value is Either" do
       subject { either.join_left }
-      let(:either) { described_class.new(Fear.left('error')) }
+      let(:either) { described_class.new(Fear.left("error")) }
 
       it { is_expected.to eq(either) }
     end
 
-    context 'value is not Either' do
+    context "value is not Either" do
       subject { either.join_left }
-      let(:either) { described_class.new('result') }
+      let(:either) { described_class.new("result") }
       it { is_expected.to eq(either) }
     end
   end
 
-  describe '#match' do
-    context 'matched' do
+  describe "#match" do
+    context "matched" do
       subject do
         right.match do |m|
           m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
@@ -125,15 +127,15 @@ RSpec.describe Fear::Right do
         end
       end
 
-      it { is_expected.to eq('Right: value') }
+      it { is_expected.to eq("Right: value") }
     end
 
-    context 'nothing matched and no else given' do
+    context "nothing matched and no else given" do
       subject do
         proc do
           right.match do |m|
             m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
-            m.left { |_| 'noop' }
+            m.left { |_| "noop" }
           end
         end
       end
@@ -141,7 +143,7 @@ RSpec.describe Fear::Right do
       it { is_expected.to raise_error(Fear::MatchError) }
     end
 
-    context 'nothing matched and else given' do
+    context "nothing matched and else given" do
       subject do
         right.match do |m|
           m.right(->(x) { x.length < 2 }) { |x| "Right: #{x}" }
@@ -153,31 +155,31 @@ RSpec.describe Fear::Right do
     end
   end
 
-  describe '#to_s' do
+  describe "#to_s" do
     subject { right.to_s }
 
     it { is_expected.to eq('#<Fear::Right value="value">') }
   end
 
-  describe 'pattern matching' do
-    subject { Fear.xcase('Right(v : Integer)') { |v:| "matched #{v}" }.call_or_else(var) { 'nothing' } }
+  describe "pattern matching" do
+    subject { Fear.xcase("Right(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
 
-    context 'right of int' do
+    context "right of int" do
       let(:var) { Fear.right(42) }
 
-      it { is_expected.to eq('matched 42') }
+      it { is_expected.to eq("matched 42") }
     end
 
-    context 'right of string' do
-      let(:var) { Fear.right('42') }
+    context "right of string" do
+      let(:var) { Fear.right("42") }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
 
-    context 'not right' do
-      let(:var) { '42' }
+    context "not right" do
+      let(:var) { "42" }
 
-      it { is_expected.to eq('nothing') }
+      it { is_expected.to eq("nothing") }
     end
   end
 end