rubocop-ast 0.5.1 → 1.0.0

data/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    class NodePattern
+      class Compiler
+        # Base class for subcompilers
+        # Implements visitor pattern
+        #
+        # Doc on how this fits in the compiling process:
+        #   /doc/modules/ROOT/pages/node_pattern.md
+        class Subcompiler
+          attr_reader :compiler
+
+          def initialize(compiler)
+            @compiler = compiler
+            @node = nil
+          end
+
+          def compile(node)
+            prev = @node
+            @node = node
+            do_compile
+          ensure
+            @node = prev
+          end
+
+          # @api private
+
+          private
+
+          attr_reader :node
+
+          def do_compile
+            send(self.class.registry.fetch(node.type, :visit_other_type))
+          end
+
+          @registry = {}
+          class << self
+            attr_reader :registry
+
+            def method_added(method)
+              @registry[Regexp.last_match(1).to_sym] = method if method =~ /^visit_(.*)/
+              super
+            end
+
+            def inherited(base)
+              us = self
+              base.class_eval { @registry = us.registry.dup }
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node_pattern/lexer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+begin
+  require_relative 'lexer.rex'
+rescue LoadError
+  msg = '*** You must run `rake generate` to generate the lexer and the parser ***'
+  puts '*' * msg.length, msg, '*' * msg.length
+  raise
+end
+
+module RuboCop
+  module AST
+    class NodePattern
+      # Lexer class for `NodePattern`
+      #
+      # Doc on how this fits in the compiling process:
+      #   /doc/modules/ROOT/pages/node_pattern.md
+      class Lexer < LexerRex
+        Error = ScanError
+
+        REGEXP_OPTIONS = {
+          'i' => ::Regexp::IGNORECASE,
+          'm' => ::Regexp::MULTILINE,
+          'x' => ::Regexp::EXTENDED,
+          'o' => 0
+        }.freeze
+        private_constant :REGEXP_OPTIONS
+
+        attr_reader :source_buffer, :comments, :tokens
+
+        def initialize(source)
+          @tokens = []
+          super()
+          parse(source)
+        end
+
+        private
+
+        # @return [token]
+        def emit(type)
+          value = ss[1] || ss.matched
+          value = yield value if block_given?
+          token = token(type, value)
+          @tokens << token
+          token
+        end
+
+        def emit_comment
+          nil
+        end
+
+        def emit_regexp
+          body = ss[1]
+          options = ss[2]
+          flag = options.each_char.map { |c| REGEXP_OPTIONS[c] }.sum
+
+          emit(:tREGEXP) { Regexp.new(body, flag) }
+        end
+
+        def do_parse
+          # Called by the generated `parse` method, do nothing here.
+        end
+
+        def token(type, value)
+          [type, value]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node_pattern/lexer.rex

@@ -0,0 +1,39 @@
+# The only difficulty is to distinguish: `fn(argument)` from `fn (sequence)`.
+# The presence of the whitespace determines if it is an _argument_ to the
+# function call `fn` or if a _sequence_ follows the function call.
+#
+# If there is the potential for an argument list, the lexer enters the state `:ARG`.
+# The rest of the times, the state is `nil`.
+#
+# In case of an argument list, :tARG_LIST is emitted instead of a '('.
+# Therefore, the token '(' always signals the beginning of a sequence.
+
+class RuboCop::AST::NodePattern::LexerRex
+
+macros
+        SYMBOL_NAME               /[\w+@*\/?!<>=~|%^-]+|\[\]=?/
+        IDENTIFIER                /[a-zA-Z_][a-zA-Z0-9_-]*/
+        REGEXP_BODY               /(?:[^\/]|\\\/)*/
+        REGEXP                    /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
+rules
+        /\s+/
+        /:(#{SYMBOL_NAME})/o      { emit :tSYMBOL, &:to_sym }
+        /"(.+?)"/                 { emit :tSTRING }
+        /[-+]?\d+\.\d+/           { emit :tNUMBER, &:to_f }
+        /[-+]?\d+/                { emit :tNUMBER, &:to_i }
+        /#{Regexp.union(
+          %w"( ) { | } [ ] < > $ ! ^ ` ... + * ? ,"
+        )}/o                      { emit ss.matched, &:to_sym }
+        /#{REGEXP}/o              { emit_regexp }
+        /%([A-Z:][a-zA-Z_:]+)/    { emit :tPARAM_CONST }
+        /%([a-z_]+)/              { emit :tPARAM_NAMED }
+        /%(\d*)/                  { emit(:tPARAM_NUMBER) { |s| s.empty? ? 1 : s.to_i } } # Map `%` to `%1`
+        /_(#{IDENTIFIER})/o       { emit :tUNIFY }
+        /_/o                      { emit :tWILDCARD }
+        /\#(#{IDENTIFIER}[!?]?)/o { @state = :ARG; emit :tFUNCTION_CALL, &:to_sym }
+        /#{IDENTIFIER}\?/o        { @state = :ARG; emit :tPREDICATE, &:to_sym }
+        /#{IDENTIFIER}/o          { emit :tNODE_TYPE, &:to_sym }
+  :ARG  /\(/                      { @state = nil; emit :tARG_LIST }
+  :ARG  //                        { @state = nil }
+        /\#.*/                    { emit_comment }
+end

data/lib/rubocop/ast/node_pattern/lexer.rex.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+#--
+# This file is automatically generated. Do not modify it.
+# Generated by: oedipus_lex version 2.5.2.
+# Source: lib/rubocop/ast/node_pattern/lexer.rex
+#++
+
+# The only difficulty is to distinguish: `fn(argument)` from `fn (sequence)`.
+# The presence of the whitespace determines if it is an _argument_ to the
+# function call `fn` or if a _sequence_ follows the function call.
+#
+# If there is the potential for an argument list, the lexer enters the state `:ARG`.
+# The rest of the times, the state is `nil`.
+#
+# In case of an argument list, :tARG_LIST is emitted instead of a '('.
+# Therefore, the token '(' always signals the beginning of a sequence.
+
+
+##
+# The generated lexer RuboCop::AST::NodePattern::LexerRex
+
+class RuboCop::AST::NodePattern::LexerRex
+  require 'strscan'
+
+  # :stopdoc:
+  SYMBOL_NAME = /[\w+@*\/?!<>=~|%^-]+|\[\]=?/
+  IDENTIFIER  = /[a-zA-Z_][a-zA-Z0-9_-]*/
+  REGEXP_BODY = /(?:[^\/]|\\\/)*/
+  REGEXP      = /\/(#{REGEXP_BODY})(?<!\\)\/([imxo]*)/
+  # :startdoc:
+  # :stopdoc:
+  class LexerError < StandardError ; end
+  class ScanError < LexerError ; end
+  # :startdoc:
+
+  ##
+  # The file name / path
+
+  attr_accessor :filename
+
+  ##
+  # The StringScanner for this lexer.
+
+  attr_accessor :ss
+
+  ##
+  # The current lexical state.
+
+  attr_accessor :state
+
+  alias :match :ss
+
+  ##
+  # The match groups for the current scan.
+
+  def matches
+    m = (1..9).map { |i| ss[i] }
+    m.pop until m[-1] or m.empty?
+    m
+  end
+
+  ##
+  # Yields on the current action.
+
+  def action
+    yield
+  end
+
+
+  ##
+  # The current scanner class. Must be overridden in subclasses.
+
+  def scanner_class
+    StringScanner
+  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
+
+  ##
+  # Parse the given string.
+
+  def parse str
+    self.ss     = scanner_class.new str
+    self.state  ||= nil
+
+    do_parse
+  end
+
+  ##
+  # Read in and parse the file at +path+.
+
+  def parse_file path
+    self.filename = path
+    open path do |f|
+      parse f.read
+    end
+  end
+
+  ##
+  # The current location in the parse.
+
+  def location
+    [
+      (filename || "<input>"),
+    ].compact.join(":")
+  end
+
+  ##
+  # Lex the next token.
+
+  def next_token
+
+    token = nil
+
+    until ss.eos? or token do
+      token =
+        case state
+        when nil then
+          case
+          when ss.skip(/\s+/) then
+            # do nothing
+          when ss.skip(/:(#{SYMBOL_NAME})/o) then
+            action { emit :tSYMBOL, &:to_sym }
+          when ss.skip(/"(.+?)"/) then
+            action { emit :tSTRING }
+          when ss.skip(/[-+]?\d+\.\d+/) then
+            action { emit :tNUMBER, &:to_f }
+          when ss.skip(/[-+]?\d+/) then
+            action { emit :tNUMBER, &:to_i }
+          when ss.skip(/#{Regexp.union(
+                    %w"( ) { | } [ ] < > $ ! ^ ` ... + * ? ,"
+                  )}/o) then
+            action { emit ss.matched, &:to_sym }
+          when ss.skip(/#{REGEXP}/o) then
+            action { emit_regexp }
+          when ss.skip(/%([A-Z:][a-zA-Z_:]+)/) then
+            action { emit :tPARAM_CONST }
+          when ss.skip(/%([a-z_]+)/) then
+            action { emit :tPARAM_NAMED }
+          when ss.skip(/%(\d*)/) then
+            action { emit(:tPARAM_NUMBER) { |s| s.empty? ? 1 : s.to_i } } # Map `%` to `%1`
+          when ss.skip(/_(#{IDENTIFIER})/o) then
+            action { emit :tUNIFY }
+          when ss.skip(/_/o) then
+            action { emit :tWILDCARD }
+          when ss.skip(/\#(#{IDENTIFIER}[!?]?)/o) then
+            action { @state = :ARG; emit :tFUNCTION_CALL, &:to_sym }
+          when ss.skip(/#{IDENTIFIER}\?/o) then
+            action { @state = :ARG; emit :tPREDICATE, &:to_sym }
+          when ss.skip(/#{IDENTIFIER}/o) then
+            action { emit :tNODE_TYPE, &:to_sym }
+          when ss.skip(/\#.*/) then
+            action { emit_comment }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        when :ARG then
+          case
+          when ss.skip(/\(/) then
+            action { @state = nil; emit :tARG_LIST }
+          when ss.skip(//) then
+            action { @state = nil }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        else
+          raise ScanError, "undefined state at #{location}: '#{state}'"
+        end # token = case state
+
+      next unless token # allow functions to trigger redo w/ nil
+    end # while
+
+    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
+      token.nil? || (Array === token && token.size >= 2)
+
+    # auto-switch state
+    self.state = token.last if token && token.first == :state
+
+    token
+  end # def next_token
+end # class

data/lib/rubocop/ast/node_pattern/method_definer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    class NodePattern
+      # Functionality to turn `match_code` into methods/lambda
+      module MethodDefiner
+        def def_node_matcher(base, method_name, **defaults)
+          def_helper(base, method_name, **defaults) do |name|
+            params = emit_params('param0 = self')
+            <<~RUBY
+              def #{name}(#{params})
+                #{VAR} = param0
+                #{compile_init}
+                #{emit_method_code}
+              end
+            RUBY
+          end
+        end
+
+        def def_node_search(base, method_name, **defaults)
+          def_helper(base, method_name, **defaults) do |name|
+            emit_node_search(name)
+          end
+        end
+
+        def compile_as_lambda
+          <<~RUBY
+            ->(#{emit_params('param0')}, block: nil) do
+              #{VAR} = param0
+              #{compile_init}
+              #{emit_lambda_code}
+            end
+          RUBY
+        end
+
+        def as_lambda
+          eval(compile_as_lambda) # rubocop:disable Security/Eval
+        end
+
+        private
+
+        # This method minimizes the closure for our method
+        def wrapping_block(method_name, **defaults)
+          proc do |*args, **values|
+            send method_name, *args, **defaults, **values
+          end
+        end
+
+        def def_helper(base, method_name, **defaults)
+          location = caller_locations(3, 1).first
+          unless defaults.empty?
+            call = :"without_defaults_#{method_name}"
+            base.send :define_method, method_name, &wrapping_block(call, **defaults)
+            method_name = call
+          end
+          src = yield method_name
+          base.class_eval(src, location.path, location.lineno)
+        end
+
+        def emit_node_search(method_name)
+          if method_name.to_s.end_with?('?')
+            on_match = 'return true'
+          else
+            args = emit_params(":#{method_name}", 'param0', forwarding: true)
+            prelude = "return enum_for(#{args}) unless block_given?\n"
+            on_match = emit_yield_capture(VAR)
+          end
+          emit_node_search_body(method_name, prelude: prelude, on_match: on_match)
+        end
+
+        def emit_node_search_body(method_name, prelude:, on_match:)
+          <<~RUBY
+            def #{method_name}(#{emit_params('param0')})
+              #{compile_init}
+              #{prelude}
+              param0.each_node do |#{VAR}|
+                if #{match_code}
+                  #{on_match}
+                end
+              end
+              nil
+            end
+          RUBY
+        end
+
+        def emit_yield_capture(when_no_capture = '', yield_with: 'yield')
+          yield_val = if captures.zero?
+                        when_no_capture
+                      elsif captures == 1
+                        'captures[0]' # Circumvent https://github.com/jruby/jruby/issues/5710
+                      else
+                        '*captures'
+                      end
+          "#{yield_with}(#{yield_val})"
+        end
+
+        def emit_retval
+          if captures.zero?
+            'true'
+          elsif captures == 1
+            'captures[0]'
+          else
+            'captures'
+          end
+        end
+
+        def emit_param_list
+          (1..positional_parameters).map { |n| "param#{n}" }.join(',')
+        end
+
+        def emit_keyword_list(forwarding: false)
+          pattern = "%<keyword>s: #{'%<keyword>s' if forwarding}"
+          named_parameters.map { |k| format(pattern, keyword: k) }.join(',')
+        end
+
+        def emit_params(*first, forwarding: false)
+          params = emit_param_list
+          keywords = emit_keyword_list(forwarding: forwarding)
+          [*first, params, keywords].reject(&:empty?).join(',')
+        end
+
+        def emit_method_code
+          <<~RUBY
+            return unless #{match_code}
+            block_given? ? #{emit_yield_capture} : (return #{emit_retval})
+          RUBY
+        end
+
+        def emit_lambda_code
+          <<~RUBY
+            return unless #{match_code}
+            block ? #{emit_yield_capture(yield_with: 'block.call')} : (return #{emit_retval})
+          RUBY
+        end
+
+        def compile_init
+          "captures = Array.new(#{captures})" if captures.positive?
+        end
+      end
+    end
+  end
+end