rubocop 0.25.0 → 0.26.0

data/lib/rubocop.rb

@@ -16,6 +16,7 @@ require 'powerpack/string/strip_indent'
 require 'rubocop/version'
 
 require 'rubocop/path_util'
+require 'rubocop/string_util'
 
 require 'rubocop/cop/util'
 require 'rubocop/cop/offense'
@@ -166,6 +167,7 @@ require 'rubocop/cop/style/indent_array'
 require 'rubocop/cop/style/indent_hash'
 require 'rubocop/cop/style/indentation_consistency'
 require 'rubocop/cop/style/indentation_width'
+require 'rubocop/cop/style/infinite_loop'
 require 'rubocop/cop/style/inline_comment'
 require 'rubocop/cop/style/lambda'
 require 'rubocop/cop/style/lambda_call'
@@ -226,9 +228,11 @@ require 'rubocop/cop/style/space_inside_block_braces'
 require 'rubocop/cop/style/space_inside_brackets'
 require 'rubocop/cop/style/space_inside_hash_literal_braces'
 require 'rubocop/cop/style/space_inside_parens'
+require 'rubocop/cop/style/space_inside_range_literal'
 require 'rubocop/cop/style/special_global_vars'
 require 'rubocop/cop/style/string_literals'
 require 'rubocop/cop/style/symbol_array'
+require 'rubocop/cop/style/symbol_proc'
 require 'rubocop/cop/style/tab'
 require 'rubocop/cop/style/trailing_blank_lines'
 require 'rubocop/cop/style/trailing_comma'
@@ -263,6 +267,7 @@ require 'rubocop/formatter/clang_style_formatter'
 require 'rubocop/formatter/progress_formatter'
 require 'rubocop/formatter/fuubar_style_formatter'
 require 'rubocop/formatter/json_formatter'
+require 'rubocop/formatter/html_formatter'
 require 'rubocop/formatter/file_list_formatter'
 require 'rubocop/formatter/offense_count_formatter'
 require 'rubocop/formatter/formatter_set'

data/lib/rubocop/cop/commissioner.rb

@@ -7,24 +7,18 @@ module RuboCop
     class Commissioner < Parser::AST::Processor
       attr_reader :errors
 
-      METHODS_NOT_DEFINED_IN_PARSER_PROCESSOR = [
-        :on_sym, :on_str, :on_int, :on_float
-      ]
-
       def self.callback_methods
-        Parser::AST::Processor.instance_methods.select do |method|
-          method.to_s =~ /^on_/
-        end + METHODS_NOT_DEFINED_IN_PARSER_PROCESSOR
+        Parser::Meta::NODE_TYPES.map { |type| "on_#{type}" }
       end
 
       # Methods that are not defined in Parser::AST::Processor
       # won't have a `super` to call. So we should not attempt
       # to invoke `super` when defining them.
       def self.call_super(callback)
-        if METHODS_NOT_DEFINED_IN_PARSER_PROCESSOR.include?(callback)
-          ''
-        else
+        if Parser::AST::Processor.method_defined?(callback)
           'super'
+        else
+          ''
         end
       end
 

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -30,7 +30,7 @@ module RuboCop
           # assignments inside blocks are not what we're looking for
           return if condition.type == :block
 
-          on_node([:begin, *EQUALS_ASGN_NODES], condition) do |asgn_node|
+          condition.each_node(:begin, *EQUALS_ASGN_NODES) do |asgn_node|
             # skip safe assignment nodes if safe assignment is allowed
             return if safe_assignment_allowed? && safe_assignment?(asgn_node)
 

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -5,16 +5,11 @@ module RuboCop
     module Lint
       # This cop checks for END blocks in method definitions.
       class EndInMethod < Cop
-        include OnMethod
-
         MSG = '`END` found in method definition. Use `at_exit` instead.'
 
-        private
-
-        def on_method(node, _method_name, _args, _body)
-          on_node(:postexe, node) do |end_node|
-            add_offense(end_node, :keyword)
-          end
+        def on_postexe(node)
+          inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
+          add_offense(node, :keyword) if inside_of_method
         end
       end
     end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -12,8 +12,8 @@ module RuboCop
 
           return unless ensure_body
 
-          on_node(:return, ensure_body) do |e|
-            add_offense(e, :expression)
+          ensure_body.each_node(:return) do |return_node|
+            add_offense(return_node, :expression)
           end
         end
       end

data/lib/rubocop/cop/lint/space_before_first_arg.rb

@@ -28,8 +28,15 @@ module RuboCop
 
           arg1 = args.first.loc.expression
           arg1_with_space = range_with_surrounding_space(arg1, :left)
+          space = Parser::Source::Range.new(arg1.source_buffer,
+                                            arg1_with_space.begin_pos,
+                                            arg1.begin_pos)
 
-          add_offense(nil, arg1) if arg1_with_space.source =~ /\A\S/
+          add_offense(space, arg1) if arg1_with_space.source =~ /\A\S/
+        end
+
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.insert_before(range, ' ') }
         end
       end
     end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -14,6 +14,7 @@ module RuboCop
       # rescue, ensure, etc.
       class UselessAssignment < Cop
         MSG = 'Useless assignment to variable - `%s`.'
+        MINIMUM_SIMILARITY_TO_SUGGEST = 0.9
 
         def join_force?(force_class)
           force_class == VariableForce
@@ -57,6 +58,9 @@ module RuboCop
               non_assignment_operator = assignment.operator.sub(/=$/, '')
               message << " Use just operator `#{non_assignment_operator}`."
             end
+          else
+            similar_name = find_similar_name(variable.name, variable.scope)
+            message << " Did you mean `#{similar_name}`?" if similar_name
           end
 
           message
@@ -72,6 +76,37 @@ module RuboCop
             body_node
           end
         end
+
+        def find_similar_name(target_name, scope)
+          names = collect_variable_like_names(scope)
+          names.delete(target_name)
+
+          scores = names.each_with_object({}) do |name, hash|
+            score = StringUtil.similarity(target_name, name)
+            hash[name] = score if score >= MINIMUM_SIMILARITY_TO_SUGGEST
+          end
+
+          most_similar_name, _max_score = scores.max_by { |_, score| score }
+          most_similar_name
+        end
+
+        def collect_variable_like_names(scope)
+          names = scope.each_node.with_object(Set.new) do |node, set|
+            if variable_like_method_invocation?(node)
+              _receiver, method_name, = *node
+              set << method_name
+            end
+          end
+
+          variable_names = scope.variables.each_value.map(&:name)
+          names.merge(variable_names)
+        end
+
+        def variable_like_method_invocation?(node)
+          return false unless node.send_type?
+          receiver, _method_name, *args = *node
+          receiver.nil? && args.empty?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -91,9 +91,8 @@ module RuboCop
             catch(:skip_children) do
               yield node
 
-              node.children.each do |child|
-                next unless child.is_a?(Parser::AST::Node)
-                scan(child, &block)
+              node.each_child_node do |child_node|
+                scan(child_node, &block)
               end
             end
           end

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -39,9 +39,9 @@ module RuboCop
               end
             end
           end
-          node.children.each do |child|
-            next unless child.is_a?(Parser::AST::Node)
-            check_nesting_level(child, max, current_level)
+
+          node.each_child_node do |child_node|
+            check_nesting_level(child_node, max, current_level)
           end
         end
 

data/lib/rubocop/cop/metrics/class_length.rb

@@ -35,8 +35,7 @@ module RuboCop
         def line_numbers_of_inner_classes(node)
           line_numbers = Set.new
 
-          on_node([:class, :module], node) do |inner_node|
-            next if inner_node.eql?(node)
+          node.each_descendant(:class, :module) do |inner_node|
             line_range = line_range(inner_node)
             line_numbers.merge(line_range)
           end

data/lib/rubocop/cop/mixin/access_modifier_node.rb

@@ -9,9 +9,13 @@ module RuboCop
       PRIVATE_NODE = s(:send, nil, :private)
       PROTECTED_NODE = s(:send, nil, :protected)
       PUBLIC_NODE = s(:send, nil, :public)
+      MODUDULE_FUNCTION_NODE = s(:send, nil, :module_function)
 
       def modifier_node?(node)
-        [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
+        [PRIVATE_NODE,
+         PROTECTED_NODE,
+         PUBLIC_NODE,
+         MODUDULE_FUNCTION_NODE].include?(node)
       end
     end
   end

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -57,7 +57,7 @@ module RuboCop
         return [] unless arg.is_a?(Parser::AST::Node)
 
         heredoc_ranges = []
-        on_node(:dstr, arg) do |n|
+        arg.each_node(:dstr) do |n|
           if n.loc.respond_to?(:heredoc_body)
             heredoc_ranges << n.loc.heredoc_body.join(n.loc.heredoc_end)
           end
@@ -66,7 +66,7 @@ module RuboCop
       end
 
       def block_comment_within?(expr)
-        processed_source.comments.select { |c| c.document? }.find do |c|
+        processed_source.comments.select(&:document?).find do |c|
           within?(c.loc.expression, expr)
         end
       end

data/lib/rubocop/cop/mixin/configurable_naming.rb

@@ -7,8 +7,8 @@ module RuboCop
     module ConfigurableNaming
       include ConfigurableEnforcedStyle
 
-      SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
-      CAMEL_CASE = /^@?[a-z][\da-zA-Z]+[!?=]?$/
+      SNAKE_CASE = /^@{0,2}[\da-z_]+[!?=]?$/
+      CAMEL_CASE = /^@{0,2}[a-z][\da-zA-Z]+[!?=]?$/
 
       def check_name(node, name, name_range)
         return if operator?(name)

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -21,11 +21,9 @@ module RuboCop
       end
 
       def complexity(node)
-        c = 1
-        on_node(self.class::COUNTED_NODES, node) do |n|
-          c += complexity_score_for(n)
+        node.each_node(self.class::COUNTED_NODES).reduce(1) do |score, n|
+          score + complexity_score_for(n)
         end
-        c
       end
     end
   end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -20,9 +20,7 @@ module RuboCop
 
         return false if body_length == 0
 
-        on_node(:lvasgn, cond) do
-          return false
-        end
+        return false if cond.each_node.any?(&:lvasgn_type?)
 
         indentation = node.loc.keyword.column
         kw_length = node.loc.keyword.size

data/lib/rubocop/cop/rails/delegate.rb

@@ -67,7 +67,7 @@ module RuboCop
           receiver, * = *body
           return false unless receiver.is_a? Parser::AST::Node
           return false unless receiver.type == :send
-          receiver.children.none? { |n| n.is_a? Parser::AST::Node }
+          receiver.child_nodes.empty?
         end
 
         def arguments_match?(args, body)

data/lib/rubocop/cop/rails/validation.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Rails
       # This cop checks for the use of old-style attribute validation macros.
       class Validation < Cop
-        MSG = 'Use the new "sexy" validations (`validates` ...).'
+        MSG = 'Prefer the new style validations `%s` over `%s`.'
 
         BLACKLIST = [:validates_acceptance_of,
                      :validates_confirmation_of,
@@ -18,11 +18,34 @@ module RuboCop
                      :validates_size_of,
                      :validates_uniqueness_of]
 
+        WHITELIST = [
+          'validates :column, acceptance: value',
+          'validates :column, confirmation: value',
+          'validates :column, exclusion: value',
+          'validates :column, format: value',
+          'validates :column, inclusion: value',
+          'validates :column, length: value',
+          'validates :column, numericality: value',
+          'validates :column, presence: value',
+          'validates :column, size: value',
+          'validates :column, uniqueness: value'
+        ]
+
         def on_send(node)
           receiver, method_name, *_args = *node
           return unless receiver.nil? && BLACKLIST.include?(method_name)
 
-          add_offense(node, :selector)
+          add_offense(node,
+                      :selector,
+                      format(MSG,
+                             preferred_method(method_name),
+                             method_name))
+        end
+
+        private
+
+        def preferred_method(method)
+          WHITELIST[BLACKLIST.index(method.to_sym)]
         end
       end
     end

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

@@ -16,7 +16,7 @@ module RuboCop
           # in such scenarios we don't want to report an offense
           return unless method_name == :instance_exec
 
-          on_node(:alias, body) { |n| ignore_node(n) }
+          body.each_node(:alias) { |n| ignore_node(n) }
         end
 
         def on_alias(node)

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

@@ -28,15 +28,25 @@ module RuboCop
           on_conditionals(node) if style == :conditionals
         end
 
+        def on_while_post(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
         def on_until(node)
           on_conditionals(node) if style == :conditionals
         end
 
+        def on_until_post(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
         private
 
         def on_conditionals(node)
-          on_node([:and, :or], node) do |my_node|
-            process_logical_op(my_node)
+          condition_node, = *node
+
+          condition_node.each_node(:and, :or) do |logical_node|
+            process_logical_op(logical_node)
           end
         end
 

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

@@ -48,7 +48,8 @@ module RuboCop
             if style == :no_braces
               corrector.remove(node.loc.begin)
               corrector.remove(node.loc.end)
-              remove_trailing_comma(node, corrector)
+              remove_leading_whitespace(node, corrector)
+              remove_trailing_comma_and_whitespace(node, corrector)
             elsif style == :braces
               corrector.insert_before(node.loc.expression, '{')
               corrector.insert_after(node.loc.expression, '}')
@@ -56,18 +57,24 @@ module RuboCop
           end
         end
 
-        def remove_trailing_comma(node, corrector)
-          sb = node.loc.end.source_buffer
-          pos_after_last_pair = node.children.last.loc.expression.end_pos
-          range_after_last_pair =
-            Parser::Source::Range.new(sb, pos_after_last_pair,
-                                      node.loc.end.begin_pos)
-          trailing_comma_offset = range_after_last_pair.source =~ /,/
-          return unless trailing_comma_offset
+        def remove_leading_whitespace(node, corrector)
+          corrector.remove(
+            Parser::Source::Range.new(
+              node.loc.expression.source_buffer,
+              node.loc.begin.end_pos,
+              node.children.first.loc.expression.begin_pos
+            )
+          )
+        end
 
-          comma_begin = pos_after_last_pair + trailing_comma_offset
-          corrector.remove(Parser::Source::Range.new(sb, comma_begin,
-                                                     comma_begin + 1))
+        def remove_trailing_comma_and_whitespace(node, corrector)
+          corrector.remove(
+            Parser::Source::Range.new(
+              node.loc.expression.source_buffer,
+              node.children.last.loc.expression.end_pos,
+              node.loc.end.begin_pos
+            )
+          )
         end
 
         def non_empty_hash?(arg)

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

@@ -27,7 +27,7 @@ module RuboCop
         private
 
         def check(ast, ast_with_comments)
-          on_node([:class, :module], ast) do |node|
+          ast.each_node(:class, :module) do |node|
             case node.type
             when :class
               _name, _superclass, body = *node

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

@@ -51,6 +51,26 @@ module RuboCop
           when :trailing then dot_line != selector_line
           end
         end
+
+        def autocorrect(node)
+          receiver, _method_name, *_args = *node
+          if node.loc.selector
+            selector = node.loc.selector
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            selector = node.loc.begin
+          end
+
+          @corrections << lambda do |corrector|
+            corrector.remove(node.loc.dot)
+            case style
+            when :leading
+              corrector.insert_before(selector, '.')
+            when :trailing
+              corrector.insert_after(receiver.loc.expression, '.')
+            end
+          end
+        end
       end
     end
   end