fear 1.2.0 → 2.0.0

data/lib/fear/extractor/grammar.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-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
-          Float(text_value)
-        end
-      end
-
-      class IntegerLiteral < Node
-        def to_matcher
-          ValueMatcher.new(value: value, node: self)
-        end
-
-        def value
-          Integer(text_value, 10)
-        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,18 +0,0 @@
-# frozen_string_literal: true
-
-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,38 +0,0 @@
-# frozen_string_literal: true
-
-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,53 +0,0 @@
-# frozen_string_literal: true
-
-require "ostruct"
-
-module Fear
-  module Extractor
-    # @abstract abstract matcher to inherit from.
-    class Matcher < OpenStruct
-      autoload :And, "fear/extractor/matcher/and"
-
-      # @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,17 +0,0 @@
-# frozen_string_literal: true
-
-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,58 +0,0 @@
-# frozen_string_literal: true
-
-require "lru_redux"
-
-module Fear
-  module Extractor
-    # Parse pattern. Used within +Fear[]+
-    class Pattern
-      DEFAULT_PATTERN_CACHE_SIZE = 10_000
-      private_constant :DEFAULT_PATTERN_CACHE_SIZE
-      @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,26 +0,0 @@
-# frozen_string_literal: true
-
-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,19 +0,0 @@
-# frozen_string_literal: true
-
-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(_)
-        Utils::EMPTY_HASH
-      end
-    end
-  end
-end

data/lib/fear/extractor.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-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)
-    public_constant :ExtractorNotFound
-
-    @mutex = Mutex.new
-    @registry = PartialFunction::EMPTY
-
-    EXTRACTOR_NOT_FOUND = proc do |klass|
-      raise ExtractorNotFound, "could not find extractor for " + klass.inspect
-    end
-    private_constant :EXTRACTOR_NOT_FOUND
-
-    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.(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