fear 0.11.0 → 1.0.0

data/lib/fear/either_api.rb

@@ -0,0 +1,21 @@
+module Fear
+  module EitherApi
+    # @param value [any]
+    # @return [Fear::Left]
+    # @example
+    #   Fear.left(42) #=> #<Fear::Left value=42>
+    #
+    def left(value)
+      Fear::Left.new(value)
+    end
+
+    # @param value [any]
+    # @return [Fear::Right]
+    # @example
+    #   Fear.right(42) #=> #<Fear::Right value=42>
+    #
+    def right(value)
+      Fear::Right.new(value)
+    end
+  end
+end

data/lib/fear/empty_partial_function.rb

@@ -1,7 +1,7 @@
 module Fear
   # Use singleton version of EmptyPartialFunction -- PartialFunction::EMPTY
   # @api private
-  module EmptyPartialFunction
+  class EmptyPartialFunction
     include PartialFunction
 
     def defined_at?(_)

data/lib/fear/extractor.rb

@@ -0,0 +1,108 @@
+require 'treetop'
+require 'fear/extractor/grammar'
+Treetop.load File.expand_path('extractor/grammar.treetop', __dir__)
+
+module Fear
+  # @api private
+  module Extractor
+    autoload :Pattern, 'fear/extractor/pattern'
+    autoload :Matcher, 'fear/extractor/matcher'
+
+    autoload :AnonymousArraySplatMatcher, 'fear/extractor/anonymous_array_splat_matcher'
+    autoload :AnyMatcher, 'fear/extractor/any_matcher'
+    autoload :ArrayHeadMatcher, 'fear/extractor/array_head_matcher'
+    autoload :ArrayMatcher, 'fear/extractor/array_matcher'
+    autoload :ArraySplatMatcher, 'fear/extractor/array_splat_matcher'
+    autoload :EmptyListMatcher, 'fear/extractor/empty_list_matcher'
+    autoload :ExtractorMatcher, 'fear/extractor/extractor_matcher'
+    autoload :IdentifierMatcher, 'fear/extractor/identifier_matcher'
+    autoload :NamedArraySplatMatcher, 'fear/extractor/named_array_splat_matcher'
+    autoload :TypedIdentifierMatcher, 'fear/extractor/typed_identifier_matcher'
+    autoload :ValueMatcher, 'fear/extractor/value_matcher'
+
+    ExtractorNotFound = Class.new(Error)
+
+    @mutex = Mutex.new
+    @registry = PartialFunction::EMPTY
+
+    EXTRACTOR_NOT_FOUND = proc do |klass|
+      raise ExtractorNotFound, 'could not find extractor for ' + klass.inspect
+    end
+
+    class << self
+      # @param klass [Class, String]
+      # @api private
+      def find_extractor(klass)
+        @registry.call_or_else(klass, &EXTRACTOR_NOT_FOUND)
+      end
+
+      # Register extractor for given class
+      # @!method register_extractor(*names, extractor)
+      #   @param names [<Class, String>, Class, String] name of a class. You can also pass alias for the name
+      #   @param extractor [Proc<any => Fear::Option>] proc taking any argument and returned Option
+      #     of extracted value('s)
+      #
+      # @example
+      #   register_extractor(Fear::Some, Fear.case(Fear::Some) { |some| some.get }.lift)
+      #
+      #   register_extractor(User, Fear.case(User) { |user|} [user.id, user.email] , )
+      #
+      # @example registering an alias. Alias should be CamelCased string
+      #   register_extractor(Fear::Some, 'Some', Fear.case(Fear::Some) { |some| some.get }.lift)
+      #
+      #   # no you can extract Fear::Some's using Some alias
+      #   m.case(Fear['Some(value : Integer)']) { |value:| value * 2 }
+      #
+      def register_extractor(*args)
+        *keys, extractor = *args
+
+        @mutex.synchronize do
+          keys.uniq.each do |key|
+            @registry = BUILD_EXTRACTOR.call(key, extractor).or_else(@registry)
+          end
+        end
+        self
+      end
+
+      BUILD_EXTRACTOR = proc do |key, extractor|
+        Fear.matcher do |m|
+          case key
+          when String
+            m.case(Module, ->(lookup) { lookup.to_s == key }) { extractor }
+            m.case(String, key) { extractor }
+          when Module
+            m.case(Module, ->(lookup) { lookup <= key }) { extractor }
+            m.case(String, key.to_s) { extractor }
+          else
+            m.case(key) { extractor } # may it be useful to register other types of keys? lambda?
+          end
+        end
+      end
+    end
+
+    # Multiple arguments extractor example
+    register_extractor('Date', proc do |other|
+      if other.class.name == 'Date'
+        Fear.some([other.year, other.month, other.day])
+      else
+        Fear.none
+      end
+    end)
+    register_extractor(Struct, Fear.case(Struct, &:to_a).lift)
+    # No argument boolean extractor example
+    register_extractor('IsEven', proc do |int|
+      if int.is_a?(Integer) && int.even?
+        Fear.some([])
+      else
+        Fear.none
+      end
+    end)
+    # Single argument extractor example
+    register_extractor('Fear::Some', 'Some', Some::EXTRACTOR)
+    register_extractor('Fear::None', 'None', NoneClass::EXTRACTOR)
+    register_extractor('Fear::Right', 'Right', Right::EXTRACTOR)
+    register_extractor('Fear::Left', 'Left', Left::EXTRACTOR)
+    register_extractor('Fear::Success', 'Success', Success::EXTRACTOR)
+    register_extractor('Fear::Failure', 'Failure', Failure::EXTRACTOR)
+  end
+end

data/lib/fear/extractor/anonymous_array_splat_matcher.rb

@@ -0,0 +1,8 @@
+module Fear
+  module Extractor
+    # Match against array splat, E.g. `[1, 2, *]` or `[1, 2, *_]`
+    #
+    class AnonymousArraySplatMatcher < ArraySplatMatcher
+    end
+  end
+end

data/lib/fear/extractor/any_matcher.rb

@@ -0,0 +1,15 @@
+module Fear
+  module Extractor
+    # Always match, E.g. `_ : Integer` without capturing variable
+    #
+    class AnyMatcher < Matcher
+      def defined_at?(_other)
+        true
+      end
+
+      def bindings(_)
+        EMPTY_HASH
+      end
+    end
+  end
+end

data/lib/fear/extractor/array_head_matcher.rb

@@ -0,0 +1,34 @@
+module Fear
+  module Extractor
+    # Part of recursive array matcher. Match against its head.
+    # @see ArrayMatcher
+    class ArrayHeadMatcher < Matcher
+      # @!attribute matcher
+      #   @return [Matcher]
+      # @!attribute index
+      #   @return [Types::Strict::Integer]
+
+      # @param other [<>]
+      def defined_at?(other)
+        if other.empty?
+          false
+        else
+          matcher.defined_at?(other.first)
+        end
+      end
+
+      # @param other [<>]
+      def bindings(other)
+        if other.empty?
+          super
+        else
+          matcher.bindings(other.first)
+        end
+      end
+
+      def failure_reason(other)
+        matcher.failure_reason(other.first)
+      end
+    end
+  end
+end

data/lib/fear/extractor/array_matcher.rb

@@ -0,0 +1,38 @@
+module Fear
+  module Extractor
+    # Recursive array matcher. Match against its head and tail
+    #
+    class ArrayMatcher < Matcher
+      # @!attribute head
+      #   @return [ArrayHeadMatcher]
+      # @!attribute tail
+      #   @return [ArrayMatcher | EmptyListMatcher]
+
+      def defined_at?(other)
+        if other.is_a?(Array)
+          head.defined_at?(other) && tail.defined_at?(other.slice(1..-1))
+        end
+      end
+
+      def bindings(other)
+        if head.is_a?(ArraySplatMatcher)
+          head.bindings(other)
+        else
+          head.bindings(other).merge(tail.bindings(other.slice(1..-1)))
+        end
+      end
+
+      def failure_reason(other)
+        if other.is_a?(Array)
+          if head.defined_at?(other)
+            tail.failure_reason(other.slice(1..-1))
+          else
+            head.failure_reason(other)
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/fear/extractor/array_splat_matcher.rb

@@ -0,0 +1,14 @@
+module Fear
+  module Extractor
+    # @abstract
+    class ArraySplatMatcher < Matcher
+      def defined_at?(_other)
+        true
+      end
+
+      def bindings(_)
+        EMPTY_HASH
+      end
+    end
+  end
+end

data/lib/fear/extractor/empty_list_matcher.rb

@@ -0,0 +1,18 @@
+module Fear
+  module Extractor
+    # Match only if array is empty
+    #
+    class EmptyListMatcher < Matcher
+      # @!attribute index
+      #   @return [Types::Strict::Integer]
+      #
+      def defined_at?(other)
+        other.empty?
+      end
+
+      def bindings(_)
+        EMPTY_HASH
+      end
+    end
+  end
+end

data/lib/fear/extractor/extractor_matcher.rb

@@ -0,0 +1,42 @@
+module Fear
+  module Extractor
+    # Match and extract pattern using registered extractor objects
+    # E.g. +Some(a : Integer)+
+    # @see Extractor.register_extractor
+    class ExtractorMatcher < Matcher
+      # @!attribute name
+      #   @return [Types::Strict::String]
+      # @!attribute arguments_matcher
+      #   @return [ArrayMatcher | EmptyListMatcher]
+      #
+
+      def initialize(*)
+        super
+        @extractor = Extractor.find_extractor(name)
+      end
+      attr_reader :extractor
+      private :extractor
+
+      def defined_at?(other)
+        extractor
+          .call(other)
+          .map { |v| arguments_matcher.defined_at?(v) }
+          .get_or_else(false)
+      end
+
+      def call_or_else(arg)
+        extractor.call(arg)
+          .map { |v| arguments_matcher.call_or_else(v) { yield arg } }
+          .get_or_else { yield arg }
+      end
+
+      def failure_reason(other)
+        extractor.call(other).match do |m|
+          m.some(->(v) { arguments_matcher.defined_at?(v) }) { Fear.none }
+          m.some { |v| arguments_matcher.failure_reason(v) }
+          m.none { super }
+        end
+      end
+    end
+  end
+end

data/lib/fear/extractor/grammar.rb

@@ -0,0 +1,201 @@
+module Fear
+  module Extractor
+    # This module contains AST nodes for GrammarParser
+    # generated by +treetop+. The sole purpose of them all is to
+    # generate matchers
+    module Grammar
+      class Node < Treetop::Runtime::SyntaxNode
+      end
+
+      class EmptyArray < Node
+        def to_matcher
+          EmptyListMatcher.new(node: self)
+        end
+      end
+
+      class ArrayLiteral < Node
+        def to_matcher
+          elements[1].to_matcher
+        end
+      end
+
+      class NonEmptyArray < Node
+        def to_matcher
+          head, tail = elements
+          ArrayMatcher.new(head: head.to_matcher, tail: tail.to_matcher, node: self)
+        end
+      end
+
+      class ArrayTail < Node
+        def to_matcher
+          elements[1].to_matcher
+        end
+      end
+
+      class ArrayHead < Node
+        def to_matcher
+          ArrayHeadMatcher.new(matcher: elements[1].to_matcher, node: elements[1])
+        end
+      end
+
+      class ArraySplat < Node
+        def to_matcher
+          elements[1].to_matcher
+        end
+      end
+
+      class AnonymousArraySplat < Node
+        def to_matcher
+          AnonymousArraySplatMatcher.new(node: self)
+        end
+      end
+
+      class FloatLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          text_value.to_f
+        end
+      end
+
+      class IntegerLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          text_value.to_i
+        end
+      end
+
+      class StringLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          elements[1].text_value
+        end
+      end
+
+      require 'yaml'
+
+      class DoubleQuotedStringLiteral < StringLiteral
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          YAML.safe_load(%(---\n"#{super}"\n))
+        end
+      end
+
+      class SymbolLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          elements[1].value.to_sym
+        end
+      end
+
+      class TrueLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: true, node: self)
+        end
+      end
+
+      class FalseLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: false, node: self)
+        end
+      end
+
+      class NilLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: nil, node: self)
+        end
+      end
+
+      class AnyIdentifier < Node
+        def to_matcher
+          AnyMatcher.new(node: self)
+        end
+      end
+
+      class Identifier < Node
+        def to_matcher
+          IdentifierMatcher.new(name: value, node: self)
+        end
+
+        def value
+          text_value.to_sym
+        end
+      end
+
+      class NamedArraySplat < Node
+        def to_matcher
+          NamedArraySplatMatcher.new(name: name, node: self)
+        end
+
+        def name
+          text_value[1..-1].to_sym
+        end
+      end
+
+      class TypeLiteral < Node
+        def to_matcher
+          ValueMatcher.new(value: value, node: self)
+        end
+
+        def value
+          Object.const_get(text_value)
+        end
+      end
+
+      class TypedIdentifier < Node
+        def to_matcher
+          identifier, type = elements.values_at(0, 2)
+          type.to_matcher.and(identifier.to_matcher)
+        end
+      end
+
+      class IdentifiedMatcher < Node
+        def to_matcher
+          identifier, matcher = elements.values_at(0, -1)
+          identifier.to_matcher.and(matcher.to_matcher)
+        end
+      end
+
+      class ExtractorLiteral < Node
+        def to_matcher
+          ExtractorMatcher.new(
+            name: extractor_name,
+            arguments_matcher: extractor_arguments,
+            node: self,
+          )
+        end
+
+        private def extractor_name
+          name = elements[0].text_value
+          if Object.const_defined?(name)
+            Object.const_get(name)
+          else
+            name
+          end
+        end
+
+        private def extractor_arguments
+          if elements[2].empty?
+            EmptyListMatcher.new(node: self)
+          else
+            elements[2].to_matcher
+          end
+        end
+      end
+    end
+  end
+end