fear 0.9.0 → 1.2.0

data/lib/fear/promise.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+begin
+  require "concurrent"
+rescue LoadError
+  puts "You must add 'concurrent-ruby' to your Gemfile in order to use Fear::Future"
+end
+
+module Fear
+  # @api private
+  class Promise < Concurrent::IVar
+    # @param options [Hash] options passed to underlying +Concurrent::Promise+
+    def initialize(**options)
+      super()
+      @options = options
+      @promise = Concurrent::Promise.new(options) do
+        Fear.try { value }.flatten
+      end
+    end
+    attr_reader :promise, :options
+    private :promise
+    private :options
+
+    def completed?
+      complete?
+    end
+
+    # @return [Fear::Future]
+    def to_future
+      Future.new(promise, options)
+    end
+
+    # Complete this promise with successful result
+    # @param value [any]
+    # @return [Boolean]
+    # @see #complete
+    def success(value)
+      complete(Fear.success(value))
+    end
+
+    # Complete this promise with failure
+    # @param value [any]
+    # @return [self]
+    # @raise [IllegalStateException]
+    # @see #complete!
+    def success!(value)
+      complete!(Fear.success(value))
+    end
+
+    # Complete this promise with failure
+    # @param error [StandardError]
+    # @return [Boolean]
+    # @see #complete
+    def failure(error)
+      complete(Fear.failure(error))
+    end
+
+    # Complete this promise with failure
+    # @param error [StandardError]
+    # @return [self]
+    # @raise [IllegalStateException]
+    # @see #complete!
+    def failure!(error)
+      complete!(Fear.failure(error))
+    end
+
+    # Complete this promise with result
+    # @param result [Fear::Try]
+    # @return [self]
+    # @raise [IllegalStateException] if promise already completed
+    def complete!(result)
+      if complete(result)
+        self
+      else
+        raise IllegalStateException, "Promise already completed."
+      end
+    end
+
+    # Complete this promise with result
+    # @param result [Fear::Try]
+    # @return [Boolean] If the promise has already been completed returns
+    #   `false`, or `true` otherwise.
+    # @raise [IllegalStateException] if promise already completed
+    #
+    def complete(result)
+      if completed?
+        false
+      else
+        set result
+        promise.execute
+        true
+      end
+    end
+  end
+end

data/lib/fear/right.rb

@@ -1,7 +1,25 @@
+# frozen_string_literal: true
+
 module Fear
   class Right
     include Either
     include RightBiased::Right
+    include RightPatternMatch.mixin
+
+    EXTRACTOR = proc do |either|
+      if Fear::Right === either
+        Fear.some([either.right_value])
+      else
+        Fear.none
+      end
+    end
+
+    public_constant :EXTRACTOR
+
+    # @api private
+    def right_value
+      value
+    end
 
     # @return [true]
     def right?
@@ -50,8 +68,8 @@ module Fear
 
     # @param reduce_right [Proc]
     # @return [any]
-    def reduce(_, reduce_right)
-      reduce_right.call(value)
+    def reduce(_reduce_left, reduce_right)
+      reduce_right.(value)
     end
 
     # @return [Either]

data/lib/fear/right_biased.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fear
   # @private
   module RightBiased
@@ -7,14 +9,14 @@ module Fear
       # Returns the value from this `RightBiased::Right` or the given argument if
       # this is a `RightBiased::Left`.
       def get_or_else(*args, &block)
-        Utils.assert_arg_or_block!('get_or_else', *args, &block)
+        Utils.assert_arg_or_block!("get_or_else", *args, &block)
         super
       end
 
       # Returns this `RightBiased::Right` or the given alternative if
       # this is a `RightBiased::Left`.
       def or_else(*args, &block)
-        Utils.assert_arg_or_block!('or_else', *args, &block)
+        Utils.assert_arg_or_block!("or_else", *args, &block)
         super.tap do |result|
           Utils.assert_type!(result, left_class, right_class)
         end
@@ -85,11 +87,6 @@ module Fear
         yield(value)
       end
 
-      # @return [Array] containing value
-      def to_a
-        [value]
-      end
-
       # @return [Option] containing value
       def to_option
         Some.new(value)
@@ -136,7 +133,7 @@ module Fear
       # @param [any]
       # @return [false]
       #
-      def include?(_)
+      def include?(_value)
         false
       end
 
@@ -164,14 +161,9 @@ module Fear
         self
       end
 
-      # @return [Array] empty array
-      def to_a
-        []
-      end
-
       # @return [None]
       def to_option
-        None.new
+        None
       end
 
       # @return [false]

data/lib/fear/right_pattern_match.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Fear
+  # @api private
+  class RightPatternMatch < EitherPatternMatch
+    def left(*)
+      self
+    end
+    alias failure left
+  end
+end

data/lib/fear/some.rb

@@ -1,8 +1,20 @@
+# frozen_string_literal: true
+
 module Fear
   class Some
     include Option
-    include Dry::Equalizer(:get)
     include RightBiased::Right
+    include SomePatternMatch.mixin
+
+    EXTRACTOR = proc do |option|
+      if Fear::Some === option
+        Fear.some([option.get])
+      else
+        Fear.none
+      end
+    end
+
+    public_constant :EXTRACTOR
 
     attr_reader :value
     protected :value
@@ -31,17 +43,57 @@ module Fear
       if yield(value)
         self
       else
-        None.new
+        None
       end
     end
 
     # @return [Option]
     def reject
       if yield(value)
-        None.new
+        None
       else
         self
       end
     end
+
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Some) && get == other.get
+    end
+
+    # @return [String]
+    def inspect
+      "#<Fear::Some get=#{value.inspect}>"
+    end
+
+    # @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/some_pattern_match.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fear
+  # @api private
+  class SomePatternMatch < OptionPatternMatch
+    # @return [Fear::OptionPatternMatch]
+    def none
+      self
+    end
+  end
+
+  private_constant :SomePatternMatch
+end

data/lib/fear/struct.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Fear
+  # Structs are like regular classes and good for modeling immutable data.
+  #
+  # A minimal struct requires just a list of attributes:
+  #
+  #     User = Fear::Struct.with_attributes(:id, :email, :admin)
+  #     john = User.new(id: 2, email: 'john@example.com', admin: false)
+  #
+  #     john.email #=> 'john@example.com'
+  #
+  # Instead of `.with_attributes` factory method you can use classic inheritance:
+  #
+  #     class User < Fear::Struct
+  #       attribute :id
+  #       attribute :email
+  #       attribute :admin
+  #     end
+  #
+  # Since structs are immutable, you are not allowed to reassign their attributes
+  #
+  #     john.email = ''john.doe@example.com'' #=> raises NoMethodError
+  #
+  # Two structs of the same type with the same attributes are equal
+  #
+  #     john1 = User.new(id: 2, email: 'john@example.com', admin: false)
+  #     john2 = User.new(id: 2, admin: false, email: 'john@example.com')
+  #     john1 == john2 #=> true
+  #
+  # You can create a shallow copy of a +Struct+ by using copy method optionally changing its attributes.
+  #
+  #     john = User.new(id: 2, email: 'john@example.com', admin: false)
+  #     admin_john = john.copy(admin: true)
+  #
+  #     john.admin #=> false
+  #     admin_john.admin #=> true
+  #
+  # It's possible to match against struct attributes. The following example extracts email from
+  # user only if user is admin
+  #
+  #     john = User.new(id: 2, email: 'john@example.com', admin: false)
+  #     john.match |m|
+  #       m.xcase('Fear::Struct(_, email, true)') do |email|
+  #         email
+  #       end
+  #     end
+  #
+  # Note, parameters got extracted in order they was defined.
+  #
+  class Struct
+    include PatternMatch.mixin
+
+    @attributes = [].freeze
+
+    class << self
+      # @param base [Fear::Struct]
+      # @api private
+      def inherited(base)
+        base.instance_variable_set(:@attributes, attributes)
+        Fear.register_extractor(base, Fear.case(base, &:to_a).lift)
+      end
+
+      # Defines attribute
+      #
+      # @param name [Symbol]
+      # @return [Symbol] attribute name
+      #
+      # @example
+      #   class User < Fear::Struct
+      #     attribute :id
+      #     attribute :email
+      #   end
+      #
+      def attribute(name)
+        name.to_sym.tap do |symbolized_name|
+          @attributes << symbolized_name
+          attr_reader symbolized_name
+        end
+      end
+
+      # Members of this struct
+      #
+      # @return [<Symbol>]
+      def attributes
+        @attributes.dup
+      end
+
+      # Creates new struct with given attributes
+      # @param members [<Symbol>]
+      # @return [Fear::Struct]
+      #
+      # @example
+      #   User = Fear::Struct.with_attributes(:id, :email, :admin) do
+      #     def admin?
+      #       @admin
+      #     end
+      #   end
+      #
+      def with_attributes(*members, &block)
+        members = members
+        block = block
+
+        Class.new(self) do
+          members.each { |member| attribute(member) }
+          class_eval(&block) if block
+        end
+      end
+    end
+
+    # @param attributes [{Symbol => any}]
+    def initialize(**attributes)
+      _check_missing_attributes!(attributes)
+      _check_unknown_attributes!(attributes)
+
+      @values = members.each_with_object([]) do |name, values|
+        attributes.fetch(name).tap do |value|
+          _set_attribute(name, value)
+          values << value
+        end
+      end
+    end
+
+    # Creates a shallow copy of this struct optionally changing the attributes arguments.
+    # @param attributes [{Symbol => any}]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(id: 2, email: 'john@example.com', admin: false)
+    #   john.admin #=> false
+    #   admin_john = john.copy(admin: true)
+    #   admin_john.admin #=> true
+    #
+    def copy(**attributes)
+      self.class.new(to_h.merge(attributes))
+    end
+
+    # Returns the struct attributes as an array of symbols
+    # @return [<Symbol>]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
+    #   john.attributes #=> [:id, :email, :admin]
+    #
+    def members
+      self.class.attributes
+    end
+
+    # Returns the values for this struct as an Array.
+    # @return [Array]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
+    #   john.to_a #=> [2, 'john@example.com', false]
+    #
+    def to_a
+      @values.dup
+    end
+
+    # @overload to_h()
+    #   Returns a Hash containing the names and values for the struct's attributes
+    #   @return [{Symbol => any}]
+    #
+    # @overload to_h(&block)
+    #   Applies block to pairs of name name and value and use them to construct hash
+    #   @yieldparam pair [<Symbol, any>] yields pair of name name and value
+    #   @return [{Symbol => any}]
+    #
+    # @example
+    #   User = Fear::Struct.new(:id, :email, :admin)
+    #   john = User.new(email: 'john@example.com', admin: false, id: 2)
+    #   john.to_h #=> {id: 2, email: 'john@example.com', admin: false}
+    #   john.to_h do |key, value|
+    #     [key.to_s, value]
+    #   end #=> {'id' => 2, 'email' => 'john@example.com', 'admin' => false}
+    #
+    def to_h(&block)
+      pairs = members.zip(@values)
+      if block_given?
+        Hash[pairs.map(&block)]
+      else
+        Hash[pairs]
+      end
+    end
+
+    # @param other [any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(other.class) && to_h == other.to_h
+    end
+
+    INSPECT_TEMPLATE = "<#Fear::Struct %{class_name} %{attributes}>"
+    private_constant :INSPECT_TEMPLATE
+
+    # @return [String]
+    #
+    # @example
+    #   User = Fear::Struct.with_attributes(:id, :email)
+    #   user = User.new(id: 2, email: 'john@exmaple.com')
+    #   user.inspect #=> "<#Fear::Struct User id=2, email=>'john@exmaple.com'>"
+    #
+    def inspect
+      attributes = to_h.map { |key, value| "#{key}=#{value.inspect}" }.join(", ")
+
+      format(INSPECT_TEMPLATE, class_name: self.class.name, attributes: attributes)
+    end
+    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
+
+      unless missing_attributes.empty?
+        raise ArgumentError, format(MISSING_KEYWORDS_ERROR, keywords: missing_attributes.join(", "))
+      end
+    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
+
+      unless unknown_attributes.empty?
+        raise ArgumentError, format(UNKNOWN_KEYWORDS_ERROR, keywords: unknown_attributes.join(", "))
+      end
+    end
+
+    # @return [void]
+    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