fear 1.1.0 → 1.2.0

data/lib/fear/future_api.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Fear
-  # rubocop: disable Metrics/LineLength
+  # rubocop: disable Layout/LineLength
   module FutureApi
     # Asynchronously evaluates the block
     # @param options [Hash] options will be passed directly to underlying +Concurrent::Promise+
@@ -17,5 +17,5 @@ module Fear
       Future.new(options, &block)
     end
   end
-  # rubocop: enable Metrics/LineLength
+  # rubocop: enable Layout/LineLength
 end

data/lib/fear/left.rb

@@ -13,6 +13,7 @@ module Fear
         Fear.none
       end
     end
+    public_constant :EXTRACTOR
 
     # @api private
     def left_value

data/lib/fear/none.rb

@@ -14,6 +14,7 @@ module Fear
         Fear.none
       end
     end
+    public_constant :EXTRACTOR
 
     # @raise [NoSuchElementError]
     def get
@@ -59,12 +60,29 @@ module Fear
     def ===(other)
       self == other
     end
+
+    # @param other [Fear::Option]
+    # @return [Fear::Option]
+    def zip(other)
+      if other.is_a?(Option)
+        Fear.none
+      else
+        raise TypeError, "can't zip with #{other.class}"
+      end
+    end
+
+    # @return [RightBiased::Left]
+    def filter_map
+      self
+    end
   end
 
   private_constant(:NoneClass)
 
   # The only instance of NoneClass
+  # @api private
   None = NoneClass.new.freeze
+  public_constant :None
 
   class << NoneClass
     def new

data/lib/fear/option.rb

@@ -82,6 +82,17 @@ module Fear
   #     Fear.some(42).map { |v| v/2 } #=> Fear.some(21)
   #     Fear.none.map { |v| v/2 }   #=> None
   #
+  # @!method filter_map(&block)
+  #   Returns a new +Some+ of truthy results (everything except +false+ or +nil+) of
+  #   running the block or +None+ otherwise.
+  #   @yieldparam [any] value
+  #   @yieldreturn [any]
+  #   @example
+  #     Fear.some(42).filter_map { |v| v/2 if v.even? } #=> Fear.some(21)
+  #     Fear.some(42).filter_map { |v| v/2 if v.odd? } #=> Fear.none
+  #     Fear.some(42).filter_map { |v| false } #=> Fear.none
+  #     Fear.none.filter_map { |v| v/2 }   #=> Fear.none
+  #
   # @!method flat_map(&block)
   #   Returns the given block applied to the value from this +Some+
   #   or returns this if this is a +None+
@@ -153,6 +164,17 @@ module Fear
   #       m.else { 'error '}
   #     end
   #
+  # @!method zip(other)
+  #   @param other [Fear::Option]
+  #   @return [Fear::Option] a +Fear::Some+ formed from this option and another option by
+  #     combining the corresponding elements in an array.
+  #
+  #   @example
+  #     Fear.some("foo").zip(Fear.some("bar")) #=> Fear.some(["foo", "bar"])
+  #     Fear.some("foo").zip(Fear.some("bar")) { |x, y| x + y } #=> Fear.some("foobar")
+  #     Fear.some("foo").zip(Fear.none) #=> Fear.none
+  #     Fear.none.zip(Fear.some("bar")) #=> Fear.none
+  #
   # @see https://github.com/scala/scala/blob/2.11.x/src/library/scala/Option.scala
   #
   module Option

data/lib/fear/option_pattern_match.rb

@@ -25,6 +25,7 @@ module Fear
   # @api private
   class OptionPatternMatch < Fear::PatternMatch
     GET_METHOD = :get.to_proc
+    private_constant :GET_METHOD
 
     # Match against Some
     #

data/lib/fear/partial_function.rb

@@ -99,6 +99,12 @@ module Fear
     # @param other [PartialFunction]
     # @return [PartialFunction] a partial function which has as domain the union of the domains
     #   of this partial function and +other+.
+    # @example
+    #   handle_even = Fear.case(:even?.to_proc) { |x| "#{x} is even" }
+    #   handle_odd = Fear.case(:odd?.to_proc) { |x| "#{x} is odd" }
+    #   handle_even_or_odd = handle_even.or_else(odd)
+    #   handle_even_or_odd.(42) #=> 42 is even
+    #   handle_even_or_odd.(42) #=> 21 is odd
     def or_else(other)
       OrElse.new(self, other)
     end

data/lib/fear/partial_function/empty.rb

@@ -4,5 +4,7 @@ module Fear
   module PartialFunction
     EMPTY = EmptyPartialFunction.new
     EMPTY.freeze
+
+    public_constant :EMPTY
   end
 end

data/lib/fear/pattern_matching_api.rb

@@ -130,6 +130,7 @@ module Fear
     #   pf = Fear.xcase('['ok', Some(body)]', ->(body:) { !body.empty? }) { }
     #
     def xcase(pattern, *guards, &function)
+      warn "NOTE: Fear.xcase is deprecated and will be removed in a future version. Use `case .. in ..` instead."
       Fear[pattern].and_then(self.case(*guards, &function))
     end
   end

data/lib/fear/right.rb

@@ -14,6 +14,8 @@ module Fear
       end
     end
 
+    public_constant :EXTRACTOR
+
     # @api private
     def right_value
       value

data/lib/fear/some.rb

@@ -14,6 +14,8 @@ module Fear
       end
     end
 
+    public_constant :EXTRACTOR
+
     attr_reader :value
     protected :value
 
@@ -67,5 +69,31 @@ module Fear
 
     # @return [String]
     alias to_s inspect
+
+    # @param other [Fear::Option]
+    # @return [Fear::Option]
+    def zip(other)
+      if other.is_a?(Option)
+        other.map do |x|
+          if block_given?
+            yield(value, x)
+          else
+            [value, x]
+          end
+        end
+      else
+        raise TypeError, "can't zip with #{other.class}"
+      end
+    end
+
+    # @return [RightBiased::Left, RightBiased::Right]
+    def filter_map(&filter)
+      map(&filter).select(&:itself)
+    end
+
+    # @return [Array<any>]
+    def deconstruct
+      [get]
+    end
   end
 end

data/lib/fear/struct.rb

@@ -192,6 +192,7 @@ module Fear
     end
 
     INSPECT_TEMPLATE = "<#Fear::Struct %{class_name} %{attributes}>"
+    private_constant :INSPECT_TEMPLATE
 
     # @return [String]
     #
@@ -208,6 +209,7 @@ module Fear
     alias to_s inspect
 
     MISSING_KEYWORDS_ERROR = "missing keywords: %{keywords}"
+    private_constant :MISSING_KEYWORDS_ERROR
 
     private def _check_missing_attributes!(provided_attributes)
       missing_attributes = members - provided_attributes.keys
@@ -218,6 +220,7 @@ module Fear
     end
 
     UNKNOWN_KEYWORDS_ERROR = "unknown keywords: %{keywords}"
+    private_constant :UNKNOWN_KEYWORDS_ERROR
 
     private def _check_unknown_attributes!(provided_attributes)
       unknown_attributes = provided_attributes.keys - members
@@ -231,5 +234,15 @@ module Fear
     private def _set_attribute(name, value)
       instance_variable_set(:"@#{name}", value)
     end
+
+    # @param keys [Hash, nil]
+    # @return [Hash]
+    def deconstruct_keys(keys)
+      if keys
+        to_h.slice(*(self.class.attributes & keys))
+      else
+        to_h
+      end
+    end
   end
 end

data/lib/fear/success.rb

@@ -13,6 +13,7 @@ module Fear
         Fear.none
       end
     end
+    public_constant :EXTRACTOR
 
     attr_reader :value
     protected :value
@@ -106,5 +107,10 @@ module Fear
 
     # @return [String]
     alias to_s inspect
+
+    # @return [<any>]
+    def deconstruct
+      [value]
+    end
   end
 end

data/lib/fear/try_pattern_match.rb

@@ -7,7 +7,10 @@ module Fear
   # @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+
     #

data/lib/fear/utils.rb

@@ -3,7 +3,20 @@
 module Fear
   # @private
   module Utils
+    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
 
     class << self
       def assert_arg_or_block!(method_name, *args)

data/lib/fear/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Fear
-  VERSION = "1.1.0"
+  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