fear 0.11.0 → 1.0.0

data/lib/fear/extractor/grammar.treetop

@@ -0,0 +1,129 @@
+# PEG grammar for pattern matching and extracting
+
+module Fear::Extractor
+  grammar Grammar
+    rule matcher
+      identified_matcher / anonymous_matcher
+    end
+
+    rule identified_matcher
+      identifier space '@' space anonymous_matcher <IdentifiedMatcher>
+    end
+
+    rule anonymous_matcher
+      array / literal / identifier / extractor / type
+    end
+
+    rule array
+      '[' (non_empty_array / array_splat / empty_array) ']' <ArrayLiteral>
+    end
+
+    rule empty_array
+      '' <EmptyArray>
+    end
+
+    rule non_empty_array
+      array_head (array_tail / empty_array) <NonEmptyArray>
+    end
+
+    rule array_tail
+      ',' (non_empty_array / array_splat) <ArrayTail>
+    end
+
+    rule array_splat
+      space? (named_array_splat / anonymous_array_splat) space? <ArraySplat>
+    end
+
+    rule array_splat_identifier
+      space? anonymous_array_splat space? <ArraySplat>
+    end
+
+    rule anonymous_array_splat
+      '*' '_'? <AnonymousArraySplat>
+    end
+
+    rule named_array_splat
+      '*' [a-z] [a-z0-9_]* <NamedArraySplat>
+    end
+
+    rule array_head
+      space? anonymous_matcher space? <ArrayHead>
+    end
+
+    rule space
+      [\s]+
+    end
+
+    rule any
+      '_' <AnyIdentifier>
+    end
+
+    rule variable_identifier
+      [a-z_] [a-z0-9_]* <Identifier>
+    end
+
+    rule identifier
+      typed_identifier / any / variable_identifier
+    end
+
+    rule typed_identifier
+      (any / variable_identifier) ' : ' type <TypedIdentifier>
+    end
+
+    rule literal
+      nil / true / false / number / string / symbol
+    end
+
+    rule number
+      float / integer
+    end
+
+    rule integer
+      ('+' / '-')? [0-9]+ <IntegerLiteral>
+    end
+
+    rule float
+      ('+' / '-')? [0-9]+ '.' [0-9]+ <FloatLiteral>
+    end
+
+    rule symbol
+      ':' (string / any / variable_identifier) <SymbolLiteral>
+    end
+
+    rule string
+      double_quoted_string / single_quoted_string
+    end
+
+    rule double_quoted_string
+      '"' ([^"\\] / '\\' . )* '"' <DoubleQuotedStringLiteral>
+    end
+
+    rule single_quoted_string
+      "'" ([^'\\] / '\\' . )* "'" <StringLiteral>
+    end
+
+    rule true
+      'true' <TrueLiteral>
+    end
+
+    rule false
+      'false' <FalseLiteral>
+    end
+
+    rule nil
+      'nil' <NilLiteral>
+    end
+
+    rule extractor
+      type '(' non_empty_array? ')' <ExtractorLiteral>
+    end
+
+    rule type
+      constant ('::' constant)* <TypeLiteral>
+    end
+
+    rule constant
+      [A-Z] [a-zA-Z0-9_]*
+    end
+  end
+end

data/lib/fear/extractor/identifier_matcher.rb

@@ -0,0 +1,16 @@
+module Fear
+  module Extractor
+    class IdentifierMatcher < Matcher
+      # @!attribute name
+      #   @return [Types::Strict::Symbol]
+
+      def defined_at?(_)
+        true
+      end
+
+      def bindings(other)
+        { name => other }
+      end
+    end
+  end
+end

data/lib/fear/extractor/matcher.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+
+module Fear
+  module Extractor
+    # @abstract abstract matcher to inherit from.
+    class Matcher < OpenStruct
+      autoload :And, 'fear/extractor/matcher/and'
+
+      EMPTY_HASH = {}.freeze
+      EMPTY_ARRAY = [].freeze
+
+      # @param node [Fear::Extractor::Grammar::Node]
+      def initialize(node:, **attributes)
+        @input = node.input
+        @input_position = node.interval.first
+        super(attributes)
+      end
+      attr_reader :input_position, :input
+      private :input
+      private :input_position
+
+      def call(arg)
+        call_or_else(arg, &PartialFunction::EMPTY)
+      end
+
+      def and(other)
+        And.new(self, other)
+      end
+
+      # @param arg [any]
+      # @yield [arg] if function not defined
+      def call_or_else(arg)
+        if defined_at?(arg)
+          bindings(arg)
+        else
+          yield arg
+        end
+      end
+
+      # Shows why matcher has failed. Use it for debugging.
+      # @example
+      #   Fear['[1, 2, _]'].failure_reason([1, 3, 4])
+      #   # it will show that the second element hasn't match
+      #
+      def failure_reason(other)
+        if defined_at?(other)
+          Fear.none
+        else
+          Fear.some("Expected `#{other.inspect}` to match:\n#{input}\n#{'~' * input_position}^")
+        end
+      end
+    end
+  end
+end

data/lib/fear/extractor/matcher/and.rb

@@ -0,0 +1,36 @@
+require 'ostruct'
+
+module Fear
+  module Extractor
+    class Matcher < OpenStruct
+      # Combine two matchers, so both should pass
+      class And < Matcher
+        def initialize(matcher1, matcher2)
+          @matcher1 = matcher1
+          @matcher2 = matcher2
+        end
+        attr_reader :matcher1, :matcher2
+
+        def defined_at?(arg)
+          matcher1.defined_at?(arg) && matcher2.defined_at?(arg)
+        end
+
+        def bindings(arg)
+          matcher1.bindings(arg).merge(matcher2.bindings(arg))
+        end
+
+        def failure_reason(arg)
+          if matcher1.defined_at?(arg)
+            if matcher2.defined_at?(arg)
+              Fear.none
+            else
+              matcher2.failure_reason(arg)
+            end
+          else
+            matcher1.failure_reason(arg)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fear/extractor/named_array_splat_matcher.rb

@@ -0,0 +1,15 @@
+module Fear
+  module Extractor
+    # Match against array splat, and capture rest of an array
+    # E.g. +[1, 2, *tail]+
+    #
+    class NamedArraySplatMatcher < ArraySplatMatcher
+      # @!attribute name
+      #   @return [Types::Strict::Symbol]
+
+      def bindings(other)
+        { name => other }
+      end
+    end
+  end
+end

data/lib/fear/extractor/pattern.rb

@@ -0,0 +1,55 @@
+require 'lru_redux'
+
+module Fear
+  module Extractor
+    # Parse pattern. Used within +Fear[]+
+    class Pattern
+      DEFAULT_PATTERN_CACHE_SIZE = 10_000
+      @pattern_cache = LruRedux::Cache.new(ENV.fetch('FEAR_PATTERNS_CACHE_SIZE', DEFAULT_PATTERN_CACHE_SIZE))
+
+      class << self
+        attr_reader :pattern_cache
+      end
+
+      def initialize(pattern)
+        @matcher = compile_pattern(pattern)
+      end
+      attr_reader :matcher
+      private :matcher
+
+      private def compile_pattern(pattern)
+        self.class.pattern_cache.getset(pattern) do
+          compile_pattern_without_cache(pattern)
+        end
+      end
+
+      private def compile_pattern_without_cache(pattern)
+        parser = Extractor::GrammarParser.new
+        if (result = parser.parse(pattern))
+          result.to_matcher
+        else
+          raise PatternSyntaxError, syntax_error_message(parser, pattern)
+        end
+      end
+
+      def ===(other)
+        matcher.defined_at?(other)
+      end
+
+      def and_then(other)
+        Fear::PartialFunction::Combined.new(matcher, other)
+      end
+
+      def failure_reason(other)
+        matcher.failure_reason(other).get_or_else { 'It matches' }
+      end
+
+      private def syntax_error_message(parser, pattern)
+        parser.failure_reason =~ /^(Expected .+) after/m
+        "#{Regexp.last_match(1).gsub("\n", '$NEWLINE')}:\n" +
+        pattern.split("\n")[parser.failure_line - 1] + "\n" \
+        "#{'~' * (parser.failure_column - 1)}^\n"
+      end
+    end
+  end
+end

data/lib/fear/extractor/typed_identifier_matcher.rb

@@ -0,0 +1,24 @@
+module Fear
+  module Extractor
+    # Match and capture identifier with specific type. E.g. +foo : Integer+
+    #
+    class TypedIdentifierMatcher < Matcher
+      # @!attribute identifier
+      #   @return [IdentifierMatcher]
+      # @!attribute type
+      #   @return [ValueMatcher]
+
+      def defined_at?(other)
+        type.defined_at?(other)
+      end
+
+      def bindings(other)
+        { identifier.name => other }
+      end
+
+      def failure_reason(other)
+        type.failure_reason(other)
+      end
+    end
+  end
+end

data/lib/fear/extractor/value_matcher.rb

@@ -0,0 +1,17 @@
+module Fear
+  module Extractor
+    # Match against values -- true, false, 1, "foo" etc.
+    class ValueMatcher < Matcher
+      # @!attribute value
+      #   @return [Any]
+
+      def defined_at?(arg)
+        value === arg
+      end
+
+      def bindings(_)
+        EMPTY_HASH
+      end
+    end
+  end
+end

data/lib/fear/extractor_api.rb

@@ -0,0 +1,33 @@
+module Fear
+  module ExtractorApi
+    # Allows to pattern match and extract matcher variables
+    #
+    # @param pattern [String]
+    # @return [Extractor::Pattern]
+    # @note it is not intended to be used by itself, rather then with partial functions
+    def [](pattern)
+      Extractor::Pattern.new(pattern)
+    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)
+      Extractor.register_extractor(*args)
+    end
+  end
+end

data/lib/fear/failure.rb

@@ -1,9 +1,15 @@
 module Fear
   class Failure
     include Try
-    include Dry::Equalizer(:exception)
     include RightBiased::Left
     include FailurePatternMatch.mixin
+    EXTRACTOR = proc do |try|
+      if Fear::Failure === try
+        Fear.some([try.exception])
+      else
+        Fear.none
+      end
+    end
 
     # @param [StandardError]
     def initialize(exception)
@@ -44,22 +50,24 @@ module Fear
       self
     end
 
-    # @yieldparam [Exception]
-    # @yieldreturn [Try]
-    # @return [Try]
+    # @yieldparam [Fear::PatternMatch]
+    # @yieldreturn [Fear::Try]
+    # @return [Fear::Try]
     def recover_with
-      yield(exception).tap do |result|
-        Utils.assert_type!(result, Success, Failure)
-      end
+      Fear.matcher { |m| yield(m) }
+        .and_then { |result| result.tap { Utils.assert_type!(result, Success, Failure) } }
+        .call_or_else(exception) { self }
     rescue StandardError => error
       Failure.new(error)
     end
 
-    # @yieldparam [Exception]
+    # @yieldparam [Fear::PatternMatch]
     # @yieldreturn [any]
-    # @return [Try]
+    # @return [Fear::Try]
     def recover
-      Success.new(yield(exception))
+      Fear.matcher { |m| yield(m) }
+        .and_then { |v| Success.new(v) }
+        .call_or_else(exception) { self }
     rescue StandardError => error
       Failure.new(error)
     end
@@ -69,6 +77,12 @@ module Fear
       Left.new(exception)
     end
 
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Failure) && exception == other.exception
+    end
+
     # Used in case statement
     # @param other [any]
     # @return [Boolean]
@@ -79,5 +93,13 @@ module Fear
         super
       end
     end
+
+    # @return [String]
+    def inspect
+      "#<Fear::Failure exception=#{exception.inspect}>"
+    end
+
+    # @return [String]
+    alias to_s inspect
   end
 end