fear 0.9.0 → 1.2.0

data/spec/fear/guard_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::PartialFunction::Guard do
+  context "Class" do
+    context "match" do
+      subject { Fear::PartialFunction::Guard.new(Integer) === 4 }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "not match" do
+      subject { Fear::PartialFunction::Guard.new(Integer) === "4" }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  context "Symbol" do
+    context "match" do
+      subject { Fear::PartialFunction::Guard.new(:even?) === :even? }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "not match" do
+      subject { Fear::PartialFunction::Guard.new(:even?) === 4 }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  context "Proc" do
+    context "match" do
+      subject { Fear::PartialFunction::Guard.new(->(x) { x.even? }) === 4 }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "not match" do
+      subject { Fear::PartialFunction::Guard.new(->(x) { x.even? }) === 3 }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe ".and" do
+    context "match" do
+      subject { guard === 4 }
+      let(:guard) { Fear::PartialFunction::Guard.and([Integer, :even?.to_proc, ->(x) { x.even? }]) }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "not match" do
+      subject { guard === 3 }
+      let(:guard) { Fear::PartialFunction::Guard.and([Integer, :even?.to_proc, ->(x) { x.even? }]) }
+
+      it { is_expected.to eq(false) }
+    end
+
+    context "empty array" do
+      subject { guard === 4 }
+      let(:guard) { Fear::PartialFunction::Guard.and([]) }
+
+      it "matches any values" do
+        is_expected.to eq(true)
+      end
+    end
+
+    context "short circuit" do
+      let(:guard) { Fear::PartialFunction::Guard.and([first, second, third]) }
+      let(:first) { ->(_) { false } }
+      let(:second) { ->(_) { raise } }
+      let(:third) { ->(_) { raise } }
+
+      it "does not call the second and the third" do
+        expect { guard === 4 }.not_to raise_error
+      end
+    end
+  end
+
+  describe ".or" do
+    let(:guard) { Fear::PartialFunction::Guard.or(["F", Integer]) }
+
+    context "match second" do
+      subject { guard === 4 }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "match first" do
+      subject { guard === "F" }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "not match" do
+      subject { guard === "A&" }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+end

data/spec/fear/left_spec.rb

@@ -1,79 +1,79 @@
-RSpec.describe Fear::Left do
-  include Fear::Either::Mixin
+# frozen_string_literal: true
 
+RSpec.describe Fear::Left do
   it_behaves_like Fear::RightBiased::Left do
-    let(:left) { Left('value') }
+    let(:left) { Fear.left("value") }
   end
 
-  let(:left) { Left('value') }
+  let(:left) { Fear.left("value") }
 
-  describe '#right?' do
+  describe "#right?" do
     subject { left }
     it { is_expected.not_to be_right }
   end
 
-  describe '#left?' do
+  describe "#left?" do
     subject { left }
     it { is_expected.to be_left }
   end
 
-  describe '#select_or_else' do
+  describe "#select_or_else" do
     subject do
-      left.select_or_else(default) { |v| v == 'value' }
+      left.select_or_else(default) { |v| v == "value" }
     end
 
-    context 'proc default' do
+    context "proc default" do
       let(:default) { -> { -1 } }
 
-      it 'returns itself' do
+      it "returns itself" do
         is_expected.to eq(left)
       end
     end
 
-    context 'default' do
+    context "default" do
       let(:default) { -1 }
 
-      it 'returns itself' do
+      it "returns itself" do
         is_expected.to eq(left)
       end
     end
   end
 
-  describe '#or_else' do
+  describe "#or_else" do
     subject { left.or_else { alternative } }
-    let(:alternative) { Left(42) }
+    let(:alternative) { Fear.left(42) }
 
-    it 'returns alternative' do
+    it "returns alternative" do
       is_expected.to eq(alternative)
     end
   end
 
-  describe '#select' do
+  describe "#select" do
     subject do
-      left.select { |v| v == 'value' }
+      left.select { |v| v == "value" }
     end
 
-    it 'return self' do
+    it "return self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#reject' do
+  describe "#reject" do
     subject do
-      left.reject { |v| v == 'value' }
+      left.reject { |v| v == "value" }
     end
 
-    it 'return self' do
+    it "return self" do
       is_expected.to eq(left)
     end
   end
 
-  describe '#swap' do
+  describe "#swap" do
     subject { left.swap }
-    it { is_expected.to eq(Right('value')) }
+    it { is_expected.to eq(Fear.right("value")) }
   end
 
-  describe '#reduce' do
+  describe "#reduce" do
     subject do
       left.reduce(
         ->(left) { "Left: #{left}" },
@@ -81,64 +81,130 @@ RSpec.describe Fear::Left do
       )
     end
 
-    it { is_expected.to eq('Left: value') }
+    it { is_expected.to eq("Left: value") }
   end
 
-  describe '#join_right' do
+  describe "#join_right" do
     subject(:join_right) { either.join_right }
 
-    context 'value is Either' do
-      let(:either) { described_class.new(Left('error')) }
+    context "value is Either" do
+      let(:either) { described_class.new(Fear.left("error")) }
       it { is_expected.to eq(either) }
     end
 
-    context 'value s not Either' do
-      let(:either) { Left('error') }
+    context "value s not Either" do
+      let(:either) { Fear.left("error") }
       it { is_expected.to eq(either) }
     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(value) }
-      let(:value) { Left('error') }
+      let(:value) { Fear.left("error") }
 
-      it 'returns value' do
-        is_expected.to eq(Left('error'))
+      it "returns value" do
+        is_expected.to eq(Fear.left("error"))
       end
     end
 
-    context 'value is not Either' do
+    context "value is not Either" do
       subject { proc { left.join_left } }
 
-      it 'fails with type error' do
+      it "fails with type error" do
         is_expected.to raise_error(TypeError)
       end
     end
   end
 
-  describe '#===' do
+  describe "#===" do
     subject { match === left }
 
-    context 'matches erectly' do
-      let(:match) { Left('value') }
+    context "matches erectly" do
+      let(:match) { Fear.left("value") }
       it { is_expected.to eq(true) }
     end
 
-    context 'value does not match' do
-      let(:match) { Left('error') }
+    context "value does not match" do
+      let(:match) { Fear.left("error") }
       it { is_expected.to eq(false) }
     end
 
-    context 'matches by class' do
-      let(:match) { Left(String) }
+    context "matches by class" do
+      let(:match) { Fear.left(String) }
       it { is_expected.to eq(true) }
     end
 
-    context 'does not matches by class' do
-      let(:match) { Left(Integer) }
+    context "does not matches by class" do
+      let(:match) { Fear.left(Integer) }
       it { is_expected.to eq(false) }
     end
   end
+
+  describe "#match" do
+    context "matched" do
+      subject do
+        left.match do |m|
+          m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
+          m.left(->(x) { x.length > 2 }) { |x| "Left: #{x}" }
+          m.right(->(x) { x.length > 2 }) { |x| "Right: #{x}" }
+        end
+      end
+
+      it { is_expected.to eq("Left: value") }
+    end
+
+    context "nothing matched and no else given" do
+      subject do
+        proc do
+          left.match do |m|
+            m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
+            m.right { |_| "noop" }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context "nothing matched and else given" do
+      subject do
+        left.match do |m|
+          m.left(->(x) { x.length < 2 }) { |x| "Left: #{x}" }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
+
+  describe "#to_s" do
+    subject { left.to_s }
+
+    it { is_expected.to eq('#<Fear::Left value="value">') }
+  end
+
+  describe "pattern matching" do
+    subject { Fear.xcase("Left(v : Integer)") { |v:| "matched #{v}" }.call_or_else(var) { "nothing" } }
+
+    context "left of int" do
+      let(:var) { Fear.left(42) }
+
+      it { is_expected.to eq("matched 42") }
+    end
+
+    context "left of string" do
+      let(:var) { Fear.left("42") }
+
+      it { is_expected.to eq("nothing") }
+    end
+
+    context "not left" do
+      let(:var) { "42" }
+
+      it { is_expected.to eq("nothing") }
+    end
+  end
 end

data/spec/fear/none_spec.rb

@@ -1,49 +1,147 @@
-RSpec.describe Fear::None do
-  include Fear::Option::Mixin
+# frozen_string_literal: true
 
+RSpec.describe "Fear::None" do
   it_behaves_like Fear::RightBiased::Left do
-    let(:left) { None() }
+    let(:left) { Fear.none }
   end
 
-  subject(:none) { None() }
+  subject(:none) { Fear.none }
 
-  describe '#get' do
+  describe "#get" do
     subject { proc { none.get } }
     it { is_expected.to raise_error(Fear::NoSuchElementError) }
   end
 
-  describe '#or_nil' do
+  describe "#or_nil" do
     subject { none.or_nil }
     it { is_expected.to eq(nil) }
   end
 
-  describe '#or_else' do
+  describe "#or_else" do
     subject { none.or_else { alternative } }
-    let(:alternative) { Some(42) }
+    let(:alternative) { Fear.some(42) }
 
-    it 'returns alternative' do
+    it "returns alternative" do
       is_expected.to eq(alternative)
     end
   end
 
-  describe '#empty?' do
+  describe "#empty?" do
     subject { none.empty? }
     it { is_expected.to eq(true) }
   end
 
-  describe '#select' do
+  describe "#select" do
     subject { none.select { |value| value > 42 } }
 
-    it 'always return None' do
-      is_expected.to eq(None())
+    it "always return None" do
+      is_expected.to eq(Fear.none)
     end
   end
 
-  describe '#reject' do
+  describe "#reject" do
     subject { none.reject { |value| value > 42 } }
 
-    it 'always return None' do
-      is_expected.to eq(None())
+    it "always return None" do
+      is_expected.to eq(Fear.none)
+    end
+  end
+
+  describe ".new" do
+    subject { Fear::None.class.new }
+
+    it { is_expected.to eq(Fear::None) }
+  end
+
+  describe ".inherited" do
+    subject { -> { Class.new(Fear.none.class) } }
+
+    it "raises error" do
+      is_expected.to raise_error(RuntimeError, "you are not allowed to inherit from NoneClass, use Fear::None instead")
+    end
+  end
+
+  describe "#to_s" do
+    subject { none.to_s }
+
+    it { is_expected.to eq("#<Fear::NoneClass>") }
+  end
+
+  describe "#inspect" do
+    subject { none.inspect }
+
+    it { is_expected.to eq("#<Fear::NoneClass>") }
+  end
+
+  describe "#===" do
+    context "None" do
+      subject { Fear::None === none }
+
+      it { is_expected.to eq(true) }
+    end
+
+    context "Fear::Some" do
+      subject { Fear::None === Fear.some(4) }
+
+      it { is_expected.to eq(false) }
+    end
+
+    context "Integer" do
+      subject { Fear::None === 4 }
+
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe "#match" do
+    context "matched" do
+      subject do
+        none.match do |m|
+          m.some { |x| x * 2 }
+          m.none { "noop" }
+        end
+      end
+
+      it { is_expected.to eq("noop") }
+    end
+
+    context "nothing matched and no else given" do
+      subject do
+        proc do
+          none.match do |m|
+            m.some { |x| x * 2 }
+          end
+        end
+      end
+
+      it { is_expected.to raise_error(Fear::MatchError) }
+    end
+
+    context "nothing matched and else given" do
+      subject do
+        none.match do |m|
+          m.some { |x| x * 2 }
+          m.else { :default }
+        end
+      end
+
+      it { is_expected.to eq(:default) }
+    end
+  end
+
+  describe "pattern matching" do
+    subject { Fear.xcase("None()") { "matched" }.call_or_else(var) { "nothing" } }
+
+    context "none" do
+      let(:var) { Fear.none }
+
+      it { is_expected.to eq("matched") }
+    end
+
+    context "not none" do
+      let(:var) { "42" }
+
+      it { is_expected.to eq("nothing") }
     end
   end
 end