rubocop 0.34.2 → 0.35.0

data/lib/rubocop/cop/style/trailing_comma.rb

@@ -68,7 +68,6 @@ module RuboCop
                 node.loc.end.begin_pos)
         end
 
-        # rubocop:disable Metrics/MethodLength
         def check(node, items, kind, begin_pos, end_pos)
           sb = items.first.loc.expression.source_buffer
 
@@ -77,10 +76,9 @@ module RuboCop
           return if heredoc?(after_last_item.source)
 
           comma_offset = after_last_item.source =~ /,/
-          should_have_comma =
-            [:comma, :consistent_comma].include?(style) && multiline?(node)
+
           if comma_offset && !inside_comment?(after_last_item, comma_offset)
-            unless should_have_comma
+            unless should_have_comma?(style, node, items)
               extra_info = case style
                            when :comma
                              ', unless each item is on its own line'
@@ -92,11 +90,16 @@ module RuboCop
               avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
                           extra_info)
             end
-          elsif should_have_comma
+          elsif should_have_comma?(style, node, items)
             put_comma(items, kind, sb)
           end
         end
-        # rubocop:enable Metrics/MethodLength
+
+        def should_have_comma?(style, node, items)
+          [:comma, :consistent_comma].include?(style) &&
+            multiline?(node) &&
+            (items.size > 1 || items.last.hash_type?)
+        end
 
         def inside_comment?(range, comma_offset)
           processed_source.comments.any? do |comment|

data/lib/rubocop/cop/style/trailing_underscore_variable.rb

@@ -15,10 +15,13 @@ module RuboCop
       #   #good
       #   a, b, = foo()
       #   a, = foo()
+      #   *a, b, _ = foo()  => We need to know to not include 2 variables in a
+      #   a, *b, _ = foo()  => The correction `a, *b, = foo()` is a syntax error
       class TrailingUnderscoreVariable < Cop
         include SurroundingSpace
 
-        MSG = 'Do not use trailing `_`s in parallel assignment.'
+        MSG = 'Do not use trailing `_`s in parallel assignment.'.freeze
+        UNDERSCORE = '_'.freeze
 
         def on_masgn(node)
           left, = *node
@@ -60,12 +63,30 @@ module RuboCop
           first_offense = nil
 
           variables.reverse_each do |variable|
-            break unless variable.children.first == :_
+            var, = *variable
+            var, = *var
+            if allow_named_underscore_variables
+              break unless var == :_
+            else
+              break unless var.to_s.start_with?(UNDERSCORE)
+            end
             first_offense = variable
           end
 
+          return nil if first_offense.nil?
+
+          first_offense_index = variables.index(first_offense)
+          0.upto(first_offense_index - 1).each do |index|
+            return nil if variables[index].splat_type?
+          end
+
           first_offense
         end
+
+        def allow_named_underscore_variables
+          @allow_named_underscore_variables ||=
+            cop_config['AllowNamedUnderscoreVariables']
+        end
       end
     end
   end

data/lib/rubocop/cop/style/unneeded_percent_q.rb

@@ -7,51 +7,62 @@ module RuboCop
       class UnneededPercentQ < Cop
         MSG = 'Use `%s` only for strings that contain both single quotes and ' \
               'double quotes%s.'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
+        SINGLE_QUOTE = "'".freeze
+        QUOTE = '"'.freeze
+        EMPTY = ''.freeze
+        PERCENT_Q = '%q'.freeze
+        PERCENT_CAPITAL_Q = '%Q'.freeze
+        STRING_INTERPOLATION_REGEXP = /#\{.+}/
 
         def on_dstr(node)
-          # Using %Q to avoid escaping inner " is ok.
-          check(node) unless node.loc.expression.source =~ /"/
+          check(node)
         end
 
         def on_str(node)
+          # Interpolated strings that contain more than just interpolation
+          # will call `on_dstr` for the entire string and `on_str` for the
+          # non interpolated portion of the string
+          return unless string_literal?(node)
           check(node)
         end
 
-        # We process regexp nodes because the inner str nodes can cause
-        # confusion in on_str if they start with %( or %Q(.
-        def on_regexp(node)
-          string_parts = node.children.select { |child| child.type == :str }
-          string_parts.each { |s| ignore_node(s) }
-        end
-
         private
 
         def check(node)
-          if node.loc.respond_to?(:heredoc_body)
-            ignore_node(node)
-            return
-          end
-          return if ignored_node?(node) || part_of_ignored_node?(node)
           src = node.loc.expression.source
-          return unless src.start_with?('%q') || src.start_with?('%Q')
-          return if src =~ /'/ && src =~ /"/
+          return unless start_with_percent_q_variant?(src)
+          return if src.include?(SINGLE_QUOTE) && src.include?(QUOTE)
           return if src =~ StringHelp::ESCAPED_CHAR_REGEXP
+          if src.start_with?(PERCENT_Q) && src =~ STRING_INTERPOLATION_REGEXP
+            return
+          end
 
-          extra = if src.start_with?('%Q')
-                    ', or for dynamic strings that contain double quotes'
+          extra = if src.start_with?(PERCENT_CAPITAL_Q)
+                    DYNAMIC_MSG
                   else
-                    ''
+                    EMPTY
                   end
           add_offense(node, :expression, format(MSG, src[0, 2], extra))
         end
 
         def autocorrect(node)
-          delimiter = node.loc.expression.source =~ /^%Q[^"]+$|'/ ? '"' : "'"
+          delimiter =
+            node.loc.expression.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
           lambda do |corrector|
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)
           end
         end
+
+        def string_literal?(node)
+          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
+            node.loc.begin && node.loc.end
+        end
+
+        def start_with_percent_q_variant?(string)
+          string.start_with?(PERCENT_Q) || string.start_with?(PERCENT_CAPITAL_Q)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/variable_name.rb

@@ -23,6 +23,11 @@ module RuboCop
           check_name(node, name, node.loc.name)
         end
 
+        def on_arg(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
         private
 
         def message(style)

data/lib/rubocop/cop/style/word_array.rb

@@ -13,6 +13,7 @@ module RuboCop
         include ConfigurableMax
 
         MSG = 'Use `%w` or `%W` for array of words.'
+        QUESTION_MARK_SIZE = '?'.size
 
         def on_array(node)
           array_elems = node.children
@@ -84,7 +85,7 @@ module RuboCop
         def source_for(str_node)
           if character_literal?(str_node)
             @interpolated = true
-            begin_pos = str_node.loc.expression.begin_pos + '?'.length
+            begin_pos = str_node.loc.expression.begin_pos + QUESTION_MARK_SIZE
             end_pos = str_node.loc.expression.end_pos
           else
             begin_pos = str_node.loc.begin.end_pos

data/lib/rubocop/cop/team.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # FIXME
     class Team
-      attr_reader :errors, :updated_source_file
+      attr_reader :errors, :warnings, :updated_source_file
 
       alias_method :updated_source_file?, :updated_source_file
 
@@ -13,6 +13,7 @@ module RuboCop
         @config = config
         @options = options || { auto_correct: false, debug: false }
         @errors = []
+        @warnings = []
       end
 
       def autocorrect?
@@ -96,13 +97,25 @@ module RuboCop
       def process_commissioner_errors(file, file_errors)
         file_errors.each do |cop, errors|
           errors.each do |e|
-            handle_error(e,
-                         Rainbow("An error occurred while #{cop.name}" \
-                         " cop was inspecting #{file}.").red)
+            if e.is_a?(Warning)
+              handle_warning(e,
+                             Rainbow("#{e.message} (from file: " \
+                             "#{file})").yellow)
+            else
+              handle_error(e,
+                           Rainbow("An error occurred while #{cop.name}" \
+                           " cop was inspecting #{file}.").red)
+            end
           end
         end
       end
 
+      def handle_warning(e, message)
+        @warnings << message
+        warn message
+        puts e.backtrace if debug?
+      end
+
       def handle_error(e, message)
         @errors << message
         warn message

data/lib/rubocop/cop/util.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+# rubocop:disable Metrics/ModuleLength
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
@@ -12,6 +13,10 @@ module RuboCop
       SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn]
       ASGN_NODES = EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES
 
+      LITERALS = [:str, :dstr, :int, :float, :sym, :dsym, :array,
+                  :hash, :regexp, :nil, :true, :false]
+      BASIC_LITERALS = LITERALS - [:dstr, :dsym, :array, :hash]
+
       # http://phrogz.net/programmingruby/language.html#table_18.4
       # Backtick is added last just to help editors parse this code.
       OPERATOR_METHODS = %w(

data/lib/rubocop/cop/variable_force/locatable.rb

@@ -133,7 +133,7 @@ module RuboCop
         end
 
         def body_index
-          branch_point_node.children.index(branch_body_node)
+          branch_point_node.children.index { |n| n.equal?(branch_body_node) }
         end
 
         def set_branch_point_and_body_nodes!

data/lib/rubocop/formatter/base_formatter.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-# rubocop:disable Metrics/LineLength, Lint/UnusedMethodArgument
+# rubocop:disable Metrics/LineLength
 
 module RuboCop
   module Formatter

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -33,11 +33,11 @@ module RuboCop
 
       def file_finished(file, offenses)
         @cops_with_offenses ||= Hash.new(0)
-        @files_with_offences ||= {}
+        @files_with_offenses ||= {}
         offenses.each do |o|
           @cops_with_offenses[o.cop_name] += 1
-          @files_with_offences[o.cop_name] ||= []
-          @files_with_offences[o.cop_name] << file
+          @files_with_offenses[o.cop_name] ||= []
+          @files_with_offenses[o.cop_name] << file
         end
       end
 
@@ -56,9 +56,7 @@ module RuboCop
           cfg = self.class.config_to_allow_offenses[cop_name]
           cfg ||= {}
           output_cop_comments(output, cfg, cop_name, offense_count)
-          output.puts "#{cop_name}:"
-          cfg.each { |key, value| output.puts "  #{key}: #{value}" }
-          output_offending_files(output, cfg, cop_name)
+          output_cop_config(output, cfg, cop_name)
         end
         puts "Created #{output.path}."
         puts "Run `rubocop --config #{output.path}`, or"
@@ -82,23 +80,37 @@ module RuboCop
         output.puts "# Configuration parameters: #{params.join(', ')}."
       end
 
+      def output_cop_config(output, cfg, cop_name)
+        output.puts "#{cop_name}:"
+        cfg.each do |key, value|
+          value = value[0] if value.is_a?(Array)
+          output.puts "  #{key}: #{value}"
+        end
+        output_offending_files(output, cfg, cop_name)
+      end
+
       def output_offending_files(output, cfg, cop_name)
         return unless cfg.empty?
 
-        offending_files = @files_with_offences[cop_name].uniq.sort
+        offending_files = @files_with_offenses[cop_name].uniq.sort
         if offending_files.count > @exclude_limit
           output.puts '  Enabled: false'
         else
-          output_exclude_list(output, offending_files)
+          output_exclude_list(output, offending_files, cop_name)
         end
       end
 
-      def output_exclude_list(output, offending_files)
+      def output_exclude_list(output, offending_files, cop_name)
         require 'pathname'
         parent = Pathname.new(Dir.pwd)
 
+        # Exclude properties in .rubocop_todo.yml override default ones, so in
+        # order to retain the default excludes we must copy them.
+        default_cfg = RuboCop::ConfigLoader.default_configuration[cop_name]
+        default_excludes = default_cfg ? default_cfg['Exclude'] || [] : []
+
         output.puts '  Exclude:'
-        offending_files.each do |file|
+        (default_excludes + offending_files).each do |file|
           file_path = Pathname.new(file)
           begin
             relative = file_path.relative_path_from(parent)

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -90,7 +90,7 @@ module RuboCop
       end
 
       def annotate_message(msg)
-        msg.gsub(/`(.*?)`/, Rainbow('\1').yellow)
+        msg.gsub(/`(.*?)`/, yellow('\1'))
       end
 
       def message(offense)

data/lib/rubocop/node_pattern.rb

@@ -0,0 +1,390 @@
+# encoding: utf-8
+
+# rubocop:disable Metrics/ClassLength
+# rubocop:disable Metrics/CyclomaticComplexity
+
+module RuboCop
+  # This class performs a pattern-matching operation on an AST node.
+  #
+  # Initialize a new `NodePattern` with `NodePattern.new(pattern_string)`, then
+  # pass an AST node to `NodePattern#match`. Alternatively, use one of the class
+  # macros in `NodePattern::Macros` to define your own pattern-matching method.
+  #
+  # If the match fails, `nil` will be returned. If the match succeeds, the
+  # return value depends on whether a block was provided to `#match`, and
+  # whether the pattern contained any "captures" (values which are extracted
+  # from a matching AST.)
+  #
+  # - With block: #match yields the captures (if any) and passes the return
+  #               value of the block through.
+  # - With no block, but one capture: the capture is returned.
+  # - With no block, but multiple captures: captures are returned as an array.
+  # - With no captures: #match returns `true`.
+  #
+  # ## Pattern string format examples
+  #
+  #    ':sym'              # matches a literal symbol
+  #    '1'                 # matches a literal integer
+  #    'nil'               # matches a literal nil
+  #    'send'              # matches (send ...)
+  #    '(send)'            # matches (send)
+  #    '(send ...)'        # matches (send ...)
+  #    '{send class}'      # matches (send ...) or (class ...)
+  #    '({send class})'    # matches (send) or (class)
+  #    '(send const)'      # matches (send (const ...))
+  #    '(send _ :new)'     # matches (send <anything> :new)
+  #    '(send $_ :new)'    # as above, but whatever matches the $_ is captured
+  #    '(send $_ $_)'      # you can use as many captures as you want
+  #    '(send !const ...)' # ! negates the next part of the pattern
+  #    '$(send const ...)' # arbitrary matching can be performed on a capture
+  #    '(send _recv _msg)' # wildcards can be named (for readability)
+  #    '(send ... :new)'   # you can specifically match against the last child
+  #                        # (this only works for the very last)
+  #    '(send $...)'       # capture all the children as an array
+  #    '(send $... int)'   # capture all children but the last as an array
+  #    '(send _x :+ _x)'   # unification is performed on named wildcards
+  #                        # (like Prolog variables...)
+  #    '(int odd?)'        # words which end with a ? are predicate methods,
+  #                        # are are called on the target to see if it matches
+  #                        # any Ruby method which the matched object supports
+  #                        # can be used
+  #    '(int [!1 !2])'     # [] contains multiple patterns, ALL of which must
+  #                        # match in that position
+  #                        # ({} is pattern union, [] is intersection)
+  #    '(send %1 _)'       # % stands for a parameter which must be supplied to
+  #                        # #match at matching time
+  #                        # it will be compared to the corresponding value in
+  #                        # the AST using #==
+  #                        # a bare '%' is the same as '%1'
+  #    '^^send'            # each ^ ascends one level in the AST
+  #                        # so this matches against the grandparent node
+  #
+  # You can nest arbitrarily deep:
+  #
+  #     # matches node parsed from 'Const = Class.new' or 'Const = Module.new':
+  #     '(casgn nil const (send (const nil {:Class :Module}) :new)))'
+  #     # matches a node parsed from an 'if', with a '==' comparison,
+  #     # and no 'else' branch:
+  #     '(if (send _ :== _) _ nil)'
+  #
+  # Note that patterns like 'send' are implemented by calling `#send_type?` on
+  # the node being matched, 'const' by `#const_type?`, 'int' by `#int_type?`,
+  # and so on. Therefore, if you add methods which are named like
+  # `#prefix_type?` to the AST node class, then 'prefix' will become usable as
+  # a pattern.
+  #
+  # Also node that if you need a "guard clause" to protect against possible nils
+  # in a certain place in the AST, you can do it like this: `[!nil <pattern>]`
+  #
+  class NodePattern
+    # @private
+    Invalid = Class.new(StandardError)
+
+    # @private
+    # Builds Ruby code which implements a pattern
+    class Compiler
+      RSYM      = %r{:(?:[\w+-@_*/?!<>~|%^]+|==|\[\]=?)}
+      ID_CHAR   = /[a-zA-Z_]/
+      META_CHAR = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
+      TOKEN     = /\G(?:\s+|#{META_CHAR}|#{ID_CHAR}+\??|%\d*|\d+|#{RSYM}|.)/
+
+      NODE      = /\A#{ID_CHAR}+\Z/
+      PREDICATE = /\A#{ID_CHAR}+\?\Z/
+      LITERAL   = /\A(?:#{RSYM}|\d+|nil)\Z/
+      WILDCARD  = /\A_#{ID_CHAR}*\Z/
+      PARAM     = /\A%\d*\Z/
+      CLOSING   = /\A(?:\)|\}|\])\Z/
+
+      attr_reader :match_code
+
+      def initialize(str, node_var = 'node0')
+        @string   = str
+
+        @temps    = 0  # avoid name clashes between temp variables
+        @captures = 0  # number of captures seen
+        @unify    = {} # named wildcard -> temp variable number
+        @params   = 0  # highest % (param) number seen
+
+        run(node_var)
+      end
+
+      def run(node_var)
+        tokens = @string.scan(TOKEN)
+        tokens.reject! { |token| token =~ /\A\s+\Z/ }
+        @match_code = compile_expr(tokens, node_var, false)
+        fail_due_to('unbalanced pattern') unless tokens.empty?
+      end
+
+      def compile_expr(tokens, cur_node, seq_head)
+        token = tokens.shift
+        case token
+        when '('       then compile_seq(tokens, cur_node, seq_head)
+        when '{'       then compile_union(tokens, cur_node, seq_head)
+        when '['       then compile_intersect(tokens, cur_node, seq_head)
+        when '!'       then compile_negation(tokens, cur_node, seq_head)
+        when '$'       then compile_capture(tokens, cur_node, seq_head)
+        when '^'       then compile_ascend(tokens, cur_node, seq_head)
+        when WILDCARD  then compile_wildcard(cur_node, token[1..-1], seq_head)
+        when LITERAL   then compile_literal(cur_node, token, seq_head)
+        when PREDICATE then compile_predicate(cur_node, token, seq_head)
+        when NODE      then compile_nodetype(cur_node, token)
+        when PARAM     then compile_param(cur_node, token[1..-1], seq_head)
+        when CLOSING   then fail_due_to("#{token} in invalid position")
+        when nil       then fail_due_to('pattern ended prematurely')
+        else fail_due_to("invalid token #{token.inspect}")
+        end
+      end
+
+      def compile_seq(tokens, cur_node, seq_head)
+        fail_due_to('empty parentheses') if tokens.first == ')'
+        fail_due_to('parentheses at sequence head') if seq_head
+
+        init = "temp#{@temps += 1} = #{cur_node}"
+        cur_node = "temp#{@temps}"
+        terms = compile_seq_terms(tokens, cur_node)
+
+        join_terms(init, terms, ' && ')
+      end
+
+      def compile_seq_terms(tokens, cur_node)
+        terms = []
+        index = nil
+        until tokens.first == ')'
+          if tokens.first == '...'
+            return compile_ellipsis(tokens, cur_node, terms, index || 0)
+          elsif tokens.first == '$...'
+            return compile_capt_ellip(tokens, cur_node, terms, index || 0)
+          elsif index.nil?
+            terms << compile_expr(tokens, cur_node, true)
+            index = 0
+          else
+            child_node = "#{cur_node}.children[#{index}]"
+            terms << compile_expr(tokens, child_node, false)
+            index += 1
+          end
+        end
+        terms << "(#{cur_node}.children.size == #{index})"
+        tokens.shift # drop concluding )
+        terms
+      end
+
+      def compile_ellipsis(tokens, cur_node, terms, index)
+        if (term = compile_seq_tail(tokens, "#{cur_node}.children.last"))
+          terms << "(#{cur_node}.children.size > #{index})"
+          terms << term
+        elsif index > 0
+          terms << "(#{cur_node}.children.size >= #{index})"
+        end
+        terms
+      end
+
+      def compile_capt_ellip(tokens, cur_node, terms, index)
+        capture = next_capture
+        if (term = compile_seq_tail(tokens, "#{cur_node}.children.last"))
+          terms << "(#{cur_node}.children.size > #{index})"
+          terms << term
+          terms << "(#{capture} = #{cur_node}.children[#{index}..-2])"
+        else
+          terms << "(#{cur_node}.children.size >= #{index})" if index > 0
+          terms << "(#{capture} = #{cur_node}.children[#{index}..-1])"
+        end
+        terms
+      end
+
+      def compile_seq_tail(tokens, cur_node)
+        tokens.shift
+        if tokens.first == ')'
+          tokens.shift
+          nil
+        else
+          expr = compile_expr(tokens, cur_node, false)
+          fail_due_to('missing )') unless tokens.shift == ')'
+          expr
+        end
+      end
+
+      def compile_union(tokens, cur_node, seq_head)
+        fail_due_to('empty union') if tokens.first == '}'
+
+        init = "temp#{@temps += 1} = #{cur_node}"
+        cur_node = "temp#{@temps}"
+
+        terms = []
+        captures_before = @captures
+        terms << compile_expr(tokens, cur_node, seq_head)
+        captures_after = @captures
+
+        until tokens.first == '}'
+          @captures = captures_before
+          terms << compile_expr(tokens, cur_node, seq_head)
+          if @captures != captures_after
+            fail_due_to('each branch of {} must have same # of captures')
+          end
+        end
+        tokens.shift
+
+        join_terms(init, terms, ' || ')
+      end
+
+      def compile_intersect(tokens, cur_node, seq_head)
+        fail_due_to('empty intersection') if tokens.first == ']'
+
+        init = "temp#{@temps += 1} = #{cur_node}"
+        cur_node = "temp#{@temps}"
+
+        terms = []
+        until tokens.first == ']'
+          terms << compile_expr(tokens, cur_node, seq_head)
+        end
+        tokens.shift
+
+        join_terms(init, terms, ' && ')
+      end
+
+      def compile_capture(tokens, cur_node, seq_head)
+        "(#{next_capture} = #{cur_node}#{'.type' if seq_head}; " <<
+          compile_expr(tokens, cur_node, seq_head) <<
+          ')'
+      end
+
+      def compile_negation(tokens, cur_node, seq_head)
+        '(!' << compile_expr(tokens, cur_node, seq_head) << ')'
+      end
+
+      def compile_ascend(tokens, cur_node, seq_head)
+        "(#{cur_node}.parent && " <<
+          compile_expr(tokens, "#{cur_node}.parent", seq_head) <<
+          ')'
+      end
+
+      def compile_wildcard(cur_node, name, seq_head)
+        if name.empty?
+          'true'
+        elsif @unify.key?(name)
+          # we have already seen a wildcard with this name before
+          # so the value it matched the first time will already be stored
+          # in a temp. check if this value matches the one stored in the temp
+          "(#{cur_node}#{'.type' if seq_head} == temp#{@unify[name]})"
+        else
+          n = @unify[name] = (@temps += 1)
+          "(temp#{n} = #{cur_node}#{'.type' if seq_head}; true)"
+        end
+      end
+
+      def compile_literal(cur_node, literal, seq_head)
+        "(#{cur_node}#{'.type' if seq_head} == #{literal})"
+      end
+
+      def compile_predicate(cur_node, predicate, seq_head)
+        "(#{cur_node}#{'.type' if seq_head}.#{predicate})"
+      end
+
+      def compile_nodetype(cur_node, type)
+        "(#{cur_node} && #{cur_node}.#{type}_type?)"
+      end
+
+      def compile_param(cur_node, number, seq_head)
+        number = number.empty? ? 1 : Integer(number)
+        @params = number if number > @params
+        "(#{cur_node}#{'.type' if seq_head} == param#{number})"
+      end
+
+      def next_capture
+        "capture#{@captures += 1}"
+      end
+
+      def join_terms(init, terms, operator)
+        '(' << init << ';' << terms.join(operator) << ')'
+      end
+
+      def emit_capture_list
+        (1..@captures).map { |n| "capture#{n}" }.join(',')
+      end
+
+      def emit_retval
+        if @captures.zero?
+          'true'
+        elsif @captures == 1
+          'capture1'
+        else
+          "[#{emit_capture_list}]"
+        end
+      end
+
+      def emit_param_list
+        (1..@params).map { |n| "param#{n}" }.join(',')
+      end
+
+      def emit_trailing_param_list
+        params = emit_param_list
+        params.empty? ? '' : ',' << params
+      end
+
+      def emit_method_code
+        <<-CODE
+          return nil unless #{@match_code}
+          block_given? ? yield(#{emit_capture_list}) : (return #{emit_retval})
+        CODE
+      end
+
+      def fail_due_to(message)
+        fail Invalid, "Couldn't compile due to #{message}. Pattern: #{@string}"
+      end
+    end
+
+    # Helpers for defining methods based on a pattern string
+    module Macros
+      # Define a method which applies a pattern to an AST node
+      #
+      # The new method will return nil if the node does not match
+      # If the node matches, and a block is provided, the new method will
+      # yield to the block (passing any captures as block arguments).
+      # If the node matches, and no block is provided, the new method will
+      # return the captures, or `true` if there were none.
+      def def_node_matcher(method_name, pattern_str)
+        compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
+        src = "def #{method_name}(node" << compiler.emit_trailing_param_list <<
+              ');' << compiler.emit_method_code << ';end'
+        class_eval(src)
+      end
+
+      # Define a method which recurses over the descendants of an AST node,
+      # checking whether any of them match the provided pattern
+      #
+      # If the method name ends with '?', the new method will return `true`
+      # as soon as it finds a descendant which matches. Otherwise, it will
+      # yield all descendants which match.
+      def def_node_search(method_name, pattern_str)
+        compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
+        if method_name.to_s.end_with?('?')
+          on_match = 'return true'
+          prelude = ''
+        else
+          yieldval = compiler.emit_capture_list
+          yieldval = 'node' if yieldval.empty?
+          on_match = "yield(#{yieldval})"
+          prelude = "return enum_for(:#{method_name},node0) unless block_given?"
+        end
+        src = <<-END
+          def #{method_name}(node0#{compiler.emit_trailing_param_list})
+            #{prelude}
+            node0.each_node do |node|
+              if #{compiler.match_code}
+                #{on_match}
+              end
+            end
+            nil
+          end
+        END
+        class_eval(src)
+      end
+    end
+
+    def initialize(str)
+      compiler = Compiler.new(str)
+      src = 'def match(node0' << compiler.emit_trailing_param_list << ');' <<
+            compiler.emit_method_code << 'end'
+      instance_eval(src)
+    end
+  end
+end