mutant 0.11.9 → 0.11.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cfe7ef3344fe2802cd0004827386547ff6e67adadfd7117bb51d3dadb8ed53d
-  data.tar.gz: f8aae5c34fa4ec0c98245641ab1773a8fe0917c56c045c0859016febdaa9e4e3
+  metadata.gz: 3c75928a9c55d93ebfad196c028271b8c82d7d9eb94e48873ac75c9ee4bb212f
+  data.tar.gz: 27149ec498db15629bb18c55a5840e3ea8c369542a85bf9d3658cadc78fc8f4a
 SHA512:
-  metadata.gz: a5c05d42faaeec2ef7e70defece4cbf35cfb5d726aefcbcc97b0ffce260851a20d2ce1815bcf0776b14d7eb1e5aef94fde299c220997f3a0d20e4acfb71b18eb
-  data.tar.gz: 2c102205b6d798214da493c263e21f587ad86354a4ff8a389ac091ec2bc212c63d563e8e5aec867c21d277e3a7881e1f3981df625324e3801eb5ff23fcf7dc20
+  metadata.gz: 44867690e5c1c367df8b22ec3fa5b35941328e12fd10a26a252baa3815c955fbd37f1adaaaadfafbcdc1f72280ce013d37996d001c163930c084b95b07905362
+  data.tar.gz: b22e71a0ae7f1ecb96345e7996e61c4ee843c7b82442f21dea3516be132503fa9c0193443f1d7da9196fbb27f23f3ef858ee58f81c03b7cda8d4f4dcced1a9a7

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