mutant 0.11.10 → 0.11.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 163279d053e71f375fc6854b89e1ca0730d7de6a1cf883772097a635067fdc92
-  data.tar.gz: c943e8ad5544a90d967ac9c580557a1e41997de4a2363cffe829710f0a71c8ae
+  metadata.gz: 6aa7e42cfe0d8ed12281745fc607d4d933fbb03af10b2bb41c41e6df3765ef89
+  data.tar.gz: 2a4a940e72bf2381816cfc0522f236166df7c2f649bd4da6ee8c2f41a6851c33
 SHA512:
-  metadata.gz: 1a130b60a8e53fb84d6b95897bc2749007df58d114b8201ac409eb40f203ee9f90804df51f49083c345784d420335eaeaa884299e0c1d37634be6d72875b5580
-  data.tar.gz: 18845045b045a1692c5574c092f7035560cab6267a8bd2a904266a69919630df59a47e0cc0d6edfc32717c834824b1b8d698da979aa7480359d363c1df9f1c1f
+  metadata.gz: 9ffa1cf3efbe20ba6ac20d7aee9765cbb8833a2934f2d1b874ec800673582c709e76bcbdb6a026191bd751a9f30726720c5f0f81b09e0999805608e22d775dc7
+  data.tar.gz: b4a2cf6f0fc16056e8f92b306828c4e5578f0b1408770b0395b4874ff887a3f1cbe5023613694493736bcdede6c906dfaed06c1b73e78f2b8b5821b2fb61457b

data/lib/mutant/ast/pattern/lexer.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    class Pattern
+      # rubocop:disable Metrics/ClassLength
+      class Lexer
+        WHITESPACE     = [' ', "\t", "\n"].to_set.freeze
+        STRING_PATTERN = /\A[a-zA-Z][_a-zA-Z0-9]*\z/.freeze
+
+        SINGLE_CHAR =
+          {
+            '(' => :group_start,
+            ')' => :group_end,
+            ',' => :delimiter,
+            '=' => :eq,
+            '{' => :properties_start,
+            '}' => :properties_end
+          }.freeze
+
+        def self.call(string)
+          new(string).__send__(:run)
+        end
+
+        class Error
+          include Anima.new(:token)
+
+          class InvalidToken < self
+            def display_message
+              <<~MESSAGE.strip
+                Invalid #{token.type} token:
+                #{token.display_location}
+              MESSAGE
+            end
+          end # Token
+        end # Error
+
+        private_class_method :new
+
+      private
+
+        def initialize(string)
+          @line_index    = 0
+          @line_start    = 0
+          @next_position = 0
+          @source        = Source.new(string: string)
+          @string        = string
+          @tokens        = []
+        end
+
+        def run
+          consume
+
+          if instance_variable_defined?(:@error)
+            Either::Left.new(@error)
+          else
+            Either::Right.new(@tokens)
+          end
+        end
+
+        def consume
+          while next? && !instance_variable_defined?(:@error)
+            skip_whitespace
+
+            consume_char || consume_string
+
+            skip_whitespace
+          end
+        end
+
+        def consume_char
+          start_position = @next_position
+
+          char = peek
+
+          type = SINGLE_CHAR.fetch(char) { return }
+
+          advance_position
+
+          @tokens << token(type: type, start_position: start_position)
+        end
+
+        def token(type:, start_position:, value: nil)
+          Token.new(
+            type:     type,
+            value:    value,
+            location: Source::Location.new(
+              source:     @source,
+              line_index: @line_index,
+              line_start: @line_start,
+              range:      range_from(start_position)
+            )
+          )
+        end
+
+        def consume_string
+          start_position = @next_position
+
+          token = build_string(start_position, read_string_body)
+
+          if valid_string?(token.value)
+            @tokens << token
+          else
+            @error = Error::InvalidToken.new(token: token)
+          end
+        end
+
+        def read_string_body
+          string = +''
+
+          while next?
+            char = peek
+            break if SINGLE_CHAR.key?(char) || whitespace?(char)
+
+            string << char
+            advance_position
+          end
+
+          string
+        end
+
+        def build_string(start_position, string)
+          token(
+            type:           :string,
+            value:          string,
+            start_position: start_position
+          )
+        end
+
+        def range_from(start_position)
+          start_position...@next_position
+        end
+
+        def valid_string?(string)
+          STRING_PATTERN.match?(string)
+        end
+
+        def advance_position
+          @next_position += 1
+        end
+
+        def skip_whitespace
+          loop do
+            char = peek
+
+            break unless whitespace?(char)
+
+            if char.eql?("\n")
+              @line_start = @next_position.succ
+              @line_index += 1
+            end
+
+            advance_position
+          end
+        end
+
+        def peek
+          @string[@next_position]
+        end
+
+        def whitespace?(char)
+          WHITESPACE.include?(char)
+        end
+
+        def next?
+          @next_position < @string.length
+        end
+      end # Lexer
+    end # Pattern
+  end # AST
+end # Mutant

data/lib/mutant/ast/pattern/parser.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    # rubocop:disable Metrics/ClassLength
+    # rubocop:disable Metrics/MethodLength
+    class Pattern
+      class Parser
+        def initialize(tokens)
+          @tokens        = tokens
+          @next_position = 0
+        end
+
+        def self.call(tokens)
+          new(tokens).__send__(:run)
+        end
+
+      private
+
+        def error?
+          instance_variable_defined?(:@error)
+        end
+
+        def run
+          node = catch(:abort) do
+            parse_node.tap do
+              if next?
+                token = peek
+                error(
+                  message: "Unexpected token: #{token.type}",
+                  token:   token
+                )
+              end
+            end
+          end
+
+          if error?
+            Either::Left.new(@error)
+          else
+            Either::Right.new(node)
+          end
+        end
+
+        def parse_node
+          structure = parse_node_type
+
+          attribute, descendant = nil
+
+          if optional(:properties_start)
+            loop do
+              break if optional(:properties_end)
+
+              name = expect(:string)
+
+              name_sym = name.value.to_sym
+
+              if structure.maybe_attribute(name_sym)
+                expect(:eq)
+                attribute = parse_attribute(name_sym)
+                next
+              end
+
+              if structure.maybe_descendant(name_sym)
+                expect(:eq)
+                descendant = parse_descendant(name_sym)
+                next
+              end
+
+              error(
+                message: "Node: #{structure.type} has no property named: #{name_sym}",
+                token:   name
+              )
+            end
+          end
+
+          Node.new(
+            attribute:  attribute,
+            descendant: descendant,
+            type:       structure.type
+          )
+        end
+
+        def parse_attribute(name)
+          Node::Attribute.new(
+            name:  name,
+            value: parse_alternative(
+              group_start: method(:parse_attribute_group),
+              string:      method(:parse_attribute_value)
+            )
+          )
+        end
+
+        def parse_alternative(alternatives)
+          token = peek
+
+          alternatives.fetch(token.type) do
+            error(
+              message: "Expected one of: #{alternatives.keys.join(',')} but got: #{token.type}",
+              token:   token
+            )
+          end.call
+        end
+
+        def parse_descendant(name)
+          Node::Descendant.new(
+            name:    name,
+            pattern: parse_node
+          )
+        end
+
+        def parse_attribute_group
+          expect(:group_start)
+
+          values = []
+
+          loop do
+            values << parse_attribute_value
+            break unless optional(:delimiter)
+          end
+
+          expect(:group_end)
+
+          Node::Attribute::Value::Group.new(values: values)
+        end
+
+        def parse_attribute_value
+          Node::Attribute::Value::Single.new(value: expect(:string).value.to_sym)
+        end
+
+        def error(message:, token: nil)
+          @error =
+            if token
+              "#{message}\n#{token.display_location}"
+            else
+              message
+            end
+
+          throw(:abort)
+        end
+
+        def optional(type)
+          token = peek
+
+          return unless token&.type.equal?(type)
+
+          advance_position
+          token
+        end
+
+        def parse_node_type
+          token = expect(:string)
+
+          type = token.value.to_sym
+
+          Structure::ALL.fetch(type) do
+            error(token: token, message: "Expected valid node type got: #{type}")
+          end
+        end
+
+        def expect(type)
+          token = peek
+
+          unless token
+            error(message: "Expected token of type: #{type}, but got no token at all")
+          end
+
+          if token.type.eql?(type)
+            advance_position
+            token
+          else
+            error(
+              token:   token,
+              message: "Expected token type: #{type} but got: #{token.type}"
+            )
+          end
+        end
+
+        def peek
+          @tokens.at(@next_position)
+        end
+
+        def advance_position
+          @next_position += 1
+        end
+
+        def next?
+          @next_position < @tokens.length
+        end
+      end
+    end # Pattern
+    # rubocop:enable Metrics/ClassLength
+    # rubocop:enable Metrics/MethodLength
+  end # AST
+end # Mutant

data/lib/mutant/ast/pattern/source.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    class Pattern
+      class Source
+        include Anima.new(:string)
+
+        def initialize(**attributes)
+          super
+
+          @lines = string.split("\n")
+        end
+
+        def line(line_index)
+          @lines.fetch(line_index)
+        end
+
+        class Location
+          include Anima.new(:source, :range, :line_index, :line_start)
+
+          def display
+            "#{source.line(line_index)}\n#{prefix}#{carets}"
+          end
+
+        private
+
+          def prefix
+            ' ' * (range.begin - line_start)
+          end
+
+          def carets
+            '^' * range.size
+          end
+        end
+      end # Source
+    end # Pattern
+  end # AST
+end # Mutant

data/lib/mutant/ast/pattern/token.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    class Pattern
+      class Token
+        include Anima.new(:type, :value, :location)
+
+        def display_location
+          location.display
+        end
+      end # Token
+    end # Pattern
+  end # AST
+end # Mutant

data/lib/mutant/ast/pattern.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Mutant
+  module AST
+    class Pattern
+      include Adamantium
+
+      def self.parse(syntax)
+        Lexer.call(syntax)
+          .lmap(&:display_message)
+          .bind(&Parser.public_method(:call))
+      end
+
+      class Node < self
+        include Anima.new(:type, :attribute, :descendant, :variable)
+
+        DEFAULTS = { attribute: nil, descendant: nil, variable: nil }.freeze
+
+        def initialize(attributes)
+          super(DEFAULTS.merge(attributes))
+        end
+
+        class Attribute
+          include Anima.new(:name, :value)
+
+          class Value
+            class Single < self
+              include Adamantium, Anima.new(:value)
+
+              def match?(input)
+                input.eql?(value)
+              end
+
+              def syntax
+                value
+              end
+            end
+
+            class Group < self
+              include Adamantium, Anima.new(:values)
+
+              def match?(value)
+                values.any? do |attribute_value|
+                  attribute_value.match?(value)
+                end
+              end
+
+              def syntax
+                "(#{values.map(&:syntax).join(',')})"
+              end
+            end # Group
+          end # Value
+
+          def match?(node)
+            attribute = Structure.for(node.type).attribute(name) and value.match?(attribute.value(node))
+          end
+
+          def syntax
+            "#{name}=#{value.syntax}"
+          end
+        end # Attribute
+
+        class Descendant
+          include Anima.new(:name, :pattern)
+
+          def match?(node)
+            descendant = Structure.for(node.type).descendant(name).value(node)
+
+            !descendant.nil? && pattern.match?(descendant)
+          end
+
+          def syntax
+            "#{name}=#{pattern.syntax}"
+          end
+        end # Descendant
+
+        def match?(node)
+          fail NotImplementedError if variable
+
+          node.type.eql?(type) \
+            && (!attribute || attribute.match?(node)) \
+            && (!descendant || descendant.match?(node))
+        end
+
+        def syntax
+          "#{type}#{pair_syntax}"
+        end
+
+      private
+
+        def pair_syntax
+          pairs = [*attribute&.syntax, *descendant&.syntax]
+
+          return if pairs.empty?
+
+          "{#{pairs.join(' ')}}"
+        end
+      end
+
+      class Any < self
+        def match?(_node)
+          true
+        end
+      end
+
+      class None < self
+        def match?(_node)
+          false
+        end
+      end
+
+      class Deep < self
+        include Anima.new(:pattern)
+
+        def match?(node)
+          Structure.for(node.type).each_node(node) do |child|
+            return true if pattern.match?(child)
+          end
+
+          false
+        end
+      end
+    end # Pattern
+  end # AST
+end # Mutant