fear 1.0.0 → 2.0.0

data/spec/fear/try_pattern_matching_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Try do
+  describe "pattern matching" do
+    subject do
+      case value
+      in Fear::Success[Integer => int]
+        "success of #{int}"
+      in Fear::Failure[RuntimeError]
+        "runtime error"
+      else
+        "something else"
+      end
+    end
+
+    context "when value is success of integer" do
+      let(:value) { Fear.try { 42 } }
+
+      it { is_expected.to eq("success of 42") }
+    end
+
+    context "when value is failure runtime error" do
+      let(:value) { Fear.try { raise } }
+
+      it { is_expected.to eq("runtime error") }
+    end
+
+    context "when value is something else" do
+      let(:value) { Fear.try { raise StandardError } }
+
+      it { is_expected.to eq("something else") }
+    end
+  end
+end

data/spec/fear/utils_spec.rb

@@ -1,58 +1,60 @@
+# frozen_string_literal: true
+
 RSpec.describe Fear::Utils do
-  describe '.assert_arg_or_block!' do
+  describe ".assert_arg_or_block!" do
     def assert_arg_or_block!(*args, &block)
       described_class.assert_arg_or_block!(:the_method, *args, &block)
     end
 
-    context 'block given, argument does not given' do
+    context "block given, argument does not given" do
       subject { proc { assert_arg_or_block! {} } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'argument given, block does not given' do
+    context "argument given, block does not given" do
       subject { proc { assert_arg_or_block!(42) } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'argument and block given at the same time' do
+    context "argument and block given at the same time" do
       subject { proc { assert_arg_or_block!(42) {} } }
 
-      it 'fails with argument error' do
+      it "fails with argument error" do
         is_expected.to raise_error(
           ArgumentError,
-          '#the_method accepts either one argument or block',
+          "#the_method accepts either one argument or block",
         )
       end
     end
 
-    context 'no argument and no block given' do
+    context "no argument and no block given" do
       subject { proc { assert_arg_or_block! } }
 
-      it 'fails with argument error' do
+      it "fails with argument error" do
         is_expected.to raise_error(
           ArgumentError,
-          '#the_method accepts either one argument or block',
+          "#the_method accepts either one argument or block",
         )
       end
     end
   end
 
-  describe 'assert_type!' do
-    context 'value is of the given type' do
+  describe "assert_type!" do
+    context "value is of the given type" do
       subject { proc { described_class.assert_type!(24, Integer) } }
 
       it { is_expected.not_to raise_error }
     end
 
-    context 'value is not of the given type' do
+    context "value is not of the given type" do
       subject { proc { described_class.assert_type!(24, String) } }
 
-      it 'raises TypeError' do
+      it "raises TypeError" do
         is_expected.to raise_error(
           TypeError,
-          'expected `24` to be of String class',
+          "expected `24` to be of String class",
         )
       end
     end

data/spec/spec_helper.rb

@@ -1,12 +1,18 @@
-# require 'codeclimate-test-reporter'
-# CodeClimate::TestReporter.start
+# frozen_string_literal: true
 
-require 'fear'
-require File.expand_path('spec/fear/right_biased/right')
-require File.expand_path('spec/fear/right_biased/left')
-require 'date'
+require "simplecov"
+
+require "fear"
+require File.expand_path("spec/fear/right_biased/right")
+require File.expand_path("spec/fear/right_biased/left")
+require "date"
+require "fear/rspec"
 
 RSpec.configure do |config|
+  unless RUBY_VERSION >= "2.7"
+    config.exclude_pattern = "**/*pattern_matching_spec.rb"
+  end
+
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest
   # assertions if you prefer.
@@ -56,7 +62,7 @@ RSpec.configure do |config|
     # Use the documentation formatter for detailed output,
     # unless a formatter has already been configured
     # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
+    config.default_formatter = "doc"
   end
 
   # Print the 10 slowest examples and example groups at the

data/spec/struct_pattern_matching_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Struct do
+  describe "pattern matching" do
+    subject do
+      case struct
+      in Fear::Struct(a: 42)
+        "a = 42"
+      in Fear::Struct(a: 43, **rest)
+        "a = 43, #{rest}"
+      in Fear::Struct(a:)
+        "a = #{a}"
+      end
+    end
+
+    let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+    context "when match single value" do
+      let(:struct) { struct_class.new(b: 43, a: 42) }
+
+      it { is_expected.to eq("a = 42") }
+    end
+
+    context "when match single value and capture the rest" do
+      let(:struct) { struct_class.new(b: 42, a: 43) }
+
+      it { is_expected.to eq("a = 43, {:b=>42}") }
+    end
+
+    context "when capture a value" do
+      let(:struct) { struct_class.new(b: 45, a: 44) }
+
+      it { is_expected.to eq("a = 44") }
+    end
+  end
+end

data/spec/struct_spec.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Struct do
+  describe ".with_attributes" do
+    context "same arguments" do
+      subject { struct_class.new(a: 42, b: 43) }
+
+      let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+      it { is_expected.to have_attributes(a: 42, b: 43) }
+    end
+
+    context "string arguments" do
+      subject { -> { struct_class.new("a" => 42, "b" => 43) } }
+
+      let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+      it { is_expected.to raise_error(ArgumentError) }
+    end
+
+    context "extra argument" do
+      subject { -> { struct_class.new(a: 42, b: 41, c: 43, d: 44) } }
+
+      let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+      it { is_expected.to raise_error(ArgumentError, "unknown keywords: c, d") }
+    end
+
+    context "missing argument" do
+      subject { -> { struct_class.new } }
+
+      let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+      it { is_expected.to raise_error(ArgumentError, "missing keywords: a, b") }
+    end
+
+    context "inheritance" do
+      let(:parent_struct) { described_class.with_attributes(:a, :b) }
+
+      it "does not change parent attributes" do
+        expect do
+          parent_struct.with_attributes(:c)
+        end.not_to change { parent_struct.attributes }.from([:a, :b])
+      end
+
+      it "extends parent attributes" do
+        child_struct = parent_struct.with_attributes(:c)
+        expect(child_struct.attributes).to eq([:a, :b, :c])
+      end
+    end
+
+    context "with block" do
+      subject { struct_class.new(a: 42, b: 43).a_plus_b }
+
+      let(:struct_class) do
+        described_class.with_attributes(:a, :b) do
+          def a_plus_b
+            a + b
+          end
+        end
+      end
+
+      it "evaluates block in context of struct" do
+        is_expected.to eq(85)
+      end
+    end
+  end
+
+  describe "#==" do
+    context "with members" do
+      let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+      context "same class and members" do
+        subject { struct_class.new(a: 42, b: 43) == struct_class.new(a: 42, b: 43) } # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
+
+        it { is_expected.to eq(true) }
+      end
+
+      context "same class and different members" do
+        subject { struct_class.new(a: 42, b: 43) == struct_class.new(a: 42, b: 0) }
+
+        it { is_expected.to eq(false) }
+      end
+
+      context "different class and same members" do
+        subject { struct_class.new(a: 42, b: 43) == struct_class_1.new(a: 42, b: 43) }
+
+        let(:struct_class_1) { described_class.with_attributes(:a, :b) }
+
+        it { is_expected.to eq(true) }
+      end
+
+      context "different class and different members" do
+        subject { struct_class.new(a: 42, b: 43) == struct_class.new(a: 42, b: 0) }
+
+        let(:struct_class_1) { described_class.with_attributes(:a, :b) }
+
+        it { is_expected.to eq(false) }
+      end
+    end
+  end
+
+  describe "#members" do
+    let(:struct) { struct_class.new(b: 43, a: 42) }
+    let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+    it "returns members in the order they defined" do
+      expect(struct.members).to eq([:a, :b])
+    end
+
+    it "is immutable" do
+      expect { struct.members << :c }.not_to change { struct.members }.from([:a, :b])
+    end
+  end
+
+  describe "#to_a" do
+    let(:struct) { struct_class.new(b: 43, a: 42) }
+    let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+    it "returns members values in the order they defined" do
+      expect(struct.to_a).to eq([42, 43])
+    end
+
+    it "is immutable" do
+      expect { struct.to_a << 44 }.not_to change { struct.to_a }.from([42, 43])
+    end
+  end
+
+  describe "#to_h" do
+    let(:struct_class) { described_class.with_attributes(:a, :b) }
+
+    context "without block" do
+      let(:struct) { struct_class.new(b: 43, a: 42) }
+
+      it "returns a Hash containing the names and values for the structs members" do
+        expect(struct.to_h).to eq(a: 42, b: 43)
+      end
+
+      it "is immutable" do
+        expect { struct.to_h.merge(c: 44) }.not_to change { struct.to_h }.from(a: 42, b: 43)
+      end
+    end
+
+    context "with block" do
+      subject do
+        struct.to_h do |key, value|
+          [key.upcase, value / 2]
+        end
+      end
+      let(:struct) { struct_class.new(b: 2, a: 4) }
+
+      it "returns a Hash containing the names and values for the structs members" do
+        is_expected.to eq(A: 2, B: 1)
+      end
+    end
+  end
+
+  describe "#copy" do
+    let(:struct_class) { described_class.with_attributes(:a, :b) }
+    let(:struct) { struct_class.new(b: 43, a: 42) }
+
+    context "attributes given" do
+      subject { struct.copy(b: 44) }
+
+      it { is_expected.to eq(struct_class.new(a: 42, b: 44)) }
+    end
+
+    context "string attributes" do
+      subject { -> { struct.copy("a" => 44) } }
+
+      it { is_expected.to raise_error(ArgumentError) }
+    end
+
+    context "no attributes given" do
+      subject { struct.copy == struct }
+
+      it { is_expected.to eq(true) }
+    end
+  end
+
+  describe "#inspect" do
+    subject { StrInspect.new(a: 2, b: nil).inspect }
+    StrInspect = Fear::Struct.with_attributes(:a, :b)
+
+    it { is_expected.to eq("<#Fear::Struct StrInspect a=2, b=nil>") }
+  end
+
+  describe "#inspect" do
+    subject { StrToS.new(a: 2, b: nil).inspect }
+    StrToS = Fear::Struct.with_attributes(:a, :b)
+
+    it { is_expected.to eq("<#Fear::Struct StrToS a=2, b=nil>") }
+  end
+end

data/spec/support/dry_types.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "dry/types/fear"
+require "dry/types/spec/types"
+
+Dry::Types.load_extensions(:fear_option)