fear 0.9.0 → 1.2.0

data/lib/fear/try_pattern_match.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fear
+  # Try pattern matcher
+  #
+  # @note it has two optimized subclasses +Fear::SuccessPatternMatch+ and +Fear::FailurePatternMatch+
+  # @api private
+  class TryPatternMatch < Fear::PatternMatch
+    SUCCESS_EXTRACTOR = :get.to_proc
+    private_constant :SUCCESS_EXTRACTOR
+
+    FAILURE_EXTRACTOR = :exception.to_proc
+    private_constant :FAILURE_EXTRACTOR
+
+    # Match against +Fear::Success+
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::TryPatternMatch]
+    def success(*conditions, &effect)
+      branch = Fear.case(Fear::Success, &SUCCESS_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+
+    # Match against +Fear::Failure+
+    #
+    # @param conditions [<#==>]
+    # @return [Fear::TryPatternMatch]
+    def failure(*conditions, &effect)
+      branch = Fear.case(Fear::Failure, &FAILURE_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
+      or_else(branch)
+    end
+  end
+end

data/lib/fear/unit.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fear
+  # Represents lack of value. It's typically returned when function completed without a value.
+  #
+  # @example
+  #   if user.valid?
+  #     Fear.right(Fear::Unit)
+  #   else
+  #     Fear.left(user.errors)
+  #   end
+  #
+  # @example
+  #   def sent_notifications(user)
+  #     # ...
+  #     Fear::Unit
+  #   end
+  #
+  Unit = Object.new.tap do |unit|
+    # @return [String]
+    def unit.to_s
+      "#<Fear::Unit>"
+    end
+
+    # @return [String]
+    def unit.inspect
+      "#<Fear::Unit>"
+    end
+  end.freeze
+
+  public_constant :Unit
+end

data/lib/fear/utils.rb

@@ -1,25 +1,50 @@
+# frozen_string_literal: true
+
 module Fear
   # @private
   module Utils
-    extend self
+    EMPTY_STRING = ""
+    public_constant :EMPTY_STRING
+
+    IDENTITY = :itself.to_proc
+    public_constant :IDENTITY
+
+    UNDEFINED = Object.new.freeze
+    public_constant :UNDEFINED
+
+    EMPTY_HASH = {}.freeze
+    public_constant :EMPTY_HASH
+
+    EMPTY_ARRAY = [].freeze
+    public_constant :EMPTY_ARRAY
 
-    def assert_arg_or_block!(method_name, *args)
-      unless block_given? ^ !args.empty?
-        fail ArgumentError, "##{method_name} accepts either one argument or block"
+    class << self
+      def assert_arg_or_block!(method_name, *args)
+        unless block_given? ^ !args.empty?
+          raise ArgumentError, "##{method_name} accepts either one argument or block"
+        end
       end
-    end
 
-    def assert_type!(value, *types)
-      if types.none? { |type| value.is_a?(type) }
-        fail TypeError, "expected `#{value.inspect}` to be of #{types.join(', ')} class"
+      def with_block_or_argument(method_name, arg = UNDEFINED, block = nil)
+        if block.nil? ^ arg.equal?(UNDEFINED)
+          yield(block || arg)
+        else
+          raise ArgumentError, "#{method_name} accepts either block or partial function"
+        end
+      end
+
+      def assert_type!(value, *types)
+        if types.none? { |type| value.is_a?(type) }
+          raise TypeError, "expected `#{value.inspect}` to be of #{types.join(", ")} class"
+        end
       end
-    end
 
-    def return_or_call_proc(value)
-      if value.respond_to?(:call)
-        value.call
-      else
-        value
+      def return_or_call_proc(value)
+        if value.respond_to?(:call)
+          value.()
+        else
+          value
+        end
       end
     end
   end

data/lib/fear/version.rb

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

data/spec/dry/types/fear/option/constrained_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Constrained, :option do
+  context "with a option type" do
+    subject(:type) do
+      Dry::Types["nominal.string"].constrained(size: 4).option
+    end
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "passes when constraints are not violated" do
+      expect(type[nil]).to be_none
+      expect(type["hell"]).to be_some_of("hell")
+    end
+
+    it "raises when a given constraint is violated" do
+      expect { type["hel"] }.to raise_error(Dry::Types::ConstraintError, /hel/)
+    end
+  end
+end

data/spec/dry/types/fear/option/core_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Nominal, :option do
+  describe "with opt-in option types" do
+    context "with strict string" do
+      let(:string) { Dry::Types["option.strict.string"] }
+
+      it_behaves_like "Dry::Types::Nominal without primitive" do
+        let(:type) { string }
+      end
+
+      it "accepts nil" do
+        expect(string[nil]).to be_none
+      end
+
+      it "accepts a string" do
+        expect(string["something"]).to be_some_of("something")
+      end
+    end
+
+    context "with coercible string" do
+      let(:string) { Dry::Types["option.coercible.string"] }
+
+      it_behaves_like "Dry::Types::Nominal without primitive" do
+        let(:type) { string }
+      end
+
+      it "accepts nil" do
+        expect(string[nil]).to be_none
+      end
+
+      it "accepts a string" do
+        expect(string[:something]).to be_some_of("something")
+      end
+    end
+  end
+
+  describe "defining coercible Option String" do
+    let(:option_string) { Dry::Types["coercible.string"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive" do
+      let(:type) { option_string }
+    end
+
+    it "accepts nil" do
+      expect(option_string[nil]).to be_none
+    end
+
+    it "accepts an object coercible to a string" do
+      expect(option_string[123]).to be_some_of("123")
+    end
+  end
+
+  describe "defining Option String" do
+    let(:option_string) { Dry::Types["strict.string"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive" do
+      let(:type) { option_string }
+    end
+
+    it "accepts nil and returns None instance" do
+      value = option_string[nil]
+
+      expect(value).to be_none
+      expect(value.map(&:downcase).map(&:upcase)).to be_none
+    end
+
+    it "accepts a string and returns Some instance" do
+      value = option_string["SomeThing"]
+
+      expect(value).to be_some_of("SomeThing")
+      expect(value.map(&:downcase).map(&:upcase)).to be_some_of("SOMETHING")
+    end
+  end
+end

data/spec/dry/types/fear/option/default_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Nominal, "#default", :option do
+  context "with a maybe" do
+    subject(:type) { Dry::Types["strict.integer"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive" do
+      let(:type) { Dry::Types["strict.integer"].option.default(0) }
+    end
+
+    it "does not allow nil" do
+      expect { type.default(nil) }.to raise_error(ArgumentError, /nil/)
+    end
+
+    it "accepts a non-nil value" do
+      expect(type.default(0)[0]).to be_some_of(0)
+    end
+  end
+end

data/spec/dry/types/fear/option/hash_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Hash, :option do
+  let(:email) { Dry::Types["option.strict.string"] }
+
+  context "Symbolized constructor" do
+    subject(:hash) do
+      Dry::Types["nominal.hash"].schema(
+        name: "string",
+        email: email,
+      ).with_key_transform(&:to_sym)
+    end
+
+    describe "#[]" do
+      it "sets None as a default value for option" do
+        result = hash["name" => "Jane"]
+
+        expect(result[:email]).to be_none
+      end
+    end
+  end
+
+  context "Schema constructor" do
+    subject(:hash) do
+      Dry::Types["nominal.hash"].schema(
+        name: "string",
+        email: email,
+      )
+    end
+
+    describe "#[]" do
+      it "sets None as a default value for option types" do
+        result = hash[name: "Jane"]
+
+        expect(result[:email]).to be_none
+      end
+    end
+  end
+
+  context "Strict with defaults" do
+    subject(:hash) do
+      Dry::Types["nominal.hash"].schema(
+        name: "string",
+        email: email,
+      )
+    end
+
+    describe "#[]" do
+      it "sets None as a default value for option types" do
+        result = hash[name: "Jane"]
+
+        expect(result[:email]).to be_none
+      end
+    end
+  end
+end

data/spec/dry/types/fear/option/option_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "support/dry_types"
+
+RSpec.describe Dry::Types::Nominal, "#option", :option do
+  context "with a nominal" do
+    subject(:type) { Dry::Types["nominal.string"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type["hello"]).to be_some_of("hello")
+    end
+
+    it "returns original if input is already a option" do
+      expect(type[Fear.some("hello")]).to be_some_of("hello")
+    end
+
+    it "aliases #[] as #call" do
+      expect(type.("hello")).to be_some_of("hello")
+    end
+
+    it "does not have primitive" do
+      expect(type).to_not respond_to(:primitive)
+    end
+  end
+
+  context "with a strict type" do
+    subject(:type) { Dry::Types["strict.integer"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type[231]).to be_some_of(231)
+    end
+  end
+
+  context "with a sum" do
+    subject(:type) { Dry::Types["nominal.bool"].option }
+
+    it_behaves_like "Dry::Types::Nominal without primitive"
+
+    it "returns None when value is nil" do
+      expect(type[nil]).to be_none
+    end
+
+    it "returns Some when value exists" do
+      expect(type[true]).to be_some_of(true)
+      expect(type[false]).to be_some_of(false)
+    end
+
+    it "does not have primitive" do
+      expect(type).to_not respond_to(:primitive)
+    end
+  end
+
+  context "with keys" do
+    subject(:type) do
+      Dry::Types["hash"].schema(foo: Dry::Types["integer"]).key(:foo)
+    end
+
+    it "gets wrapped by key type" do
+      expect(type.option).to be_a(Dry::Types::Schema::Key)
+      expect(type.option[nil]).to be_none
+      expect(type.option[1]).to be_some_of(1)
+    end
+  end
+
+  describe "#try" do
+    subject(:type) { Dry::Types["coercible.integer"].option }
+
+    it "maps successful result" do
+      expect(type.try("1")).to eq(Dry::Types::Result::Success.new(Fear.some(1)))
+      expect(type.try(nil)).to eq(Dry::Types::Result::Success.new(Fear.none))
+      expect(type.try("a")).to be_a(Dry::Types::Result::Failure)
+    end
+  end
+
+  describe "#call" do
+    describe "safe calls" do
+      subject(:type) { Dry::Types["coercible.integer"].option }
+
+      specify do
+        expect(type.("a") { :fallback }).to be(:fallback)
+        expect(type.(Fear.some(1)) { :fallback }).to eq(Fear.some(1))
+      end
+    end
+  end
+end

data/spec/fear/awaitable_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe Fear::Awaitable do
+  subject(:awaitable) { Object.new.extend(Fear::Awaitable) }
+
+  describe "#__ready__" do
+    it "must implement the method" do
+      expect { awaitable.__ready__(1) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#__result__" do
+    it "must implement the method" do
+      expect { awaitable.__result__(1) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/fear/done_spec.rb

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