fear 1.0.0 → 2.0.0

data/lib/fear/extractor/grammar.rb

@@ -1,201 +0,0 @@
-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

data/lib/fear/extractor/grammar.treetop

@@ -1,129 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-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/and.rb

@@ -1,36 +0,0 @@
-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/matcher.rb

@@ -1,54 +0,0 @@
-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/named_array_splat_matcher.rb

@@ -1,15 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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.rb

@@ -1,108 +0,0 @@
-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_api.rb

@@ -1,33 +0,0 @@
-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