rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -21,7 +22,7 @@ module RuboCop
         include IfNode
 
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
-              'precedence.'
+              'precedence.'.freeze
 
         def on_send(node)
           _receiver, method_name, *args = *node
@@ -31,10 +32,10 @@ module RuboCop
 
           if ternary_op?(args.first)
             check_ternary(args.first, node)
-          else
+          elsif predicate?(method_name)
             # We're only checking predicate methods. There would be false
             # positives otherwise.
-            check_send(args.last, node) if predicate?(method_name)
+            check_send(args.last, node)
           end
         end
 
@@ -44,10 +45,10 @@ module RuboCop
           condition, = *arg
           return unless offense?(condition)
 
-          expr = node.loc.expression
+          expr = node.source_range
           range = Parser::Source::Range.new(expr.source_buffer,
                                             expr.begin_pos,
-                                            condition.loc.expression.end_pos)
+                                            condition.source_range.end_pos)
           add_offense(range, range)
         end
 

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks for *rescue* blocks targeting the Exception class.
       class RescueException < Cop
         MSG = 'Avoid rescuing the `Exception` class. ' \
-              'Perhaps you meant to rescue `StandardError`?'
+              'Perhaps you meant to rescue `StandardError`?'.freeze
 
         def on_resbody(node)
           return unless node.children.first
@@ -17,7 +18,7 @@ module RuboCop
         end
 
         def targets_exception?(rescue_arg_node)
-          Util.const_name(rescue_arg_node) == 'Exception'
+          rescue_arg_node.const_name == 'Exception'
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -8,7 +9,7 @@ module RuboCop
       # This is a mimic of the warning
       # "shadowing outer local variable - foo" from `ruby -cw`.
       class ShadowingOuterLocalVariable < Cop
-        MSG = 'Shadowing outer local variable - `%s`.'
+        MSG = 'Shadowing outer local variable - `%s`.'.freeze
 
         def join_force?(force_class)
           force_class == VariableForce

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,8 +11,9 @@ module RuboCop
       #
       #   "result is #{something.to_s}"
       class StringConversionInInterpolation < Cop
-        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
-        MSG_SELF = 'Use `self` instead of `Object#to_s` in interpolation.'
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'.freeze
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
+                   'interpolation.'.freeze
 
         def on_dstr(node)
           node.children.select { |n| n.type == :begin }.each do |begin_node|
@@ -35,9 +37,9 @@ module RuboCop
           lambda do |corrector|
             receiver, _method_name, *_args = *node
             corrector.replace(
-              node.loc.expression,
+              node.source_range,
               if receiver
-                receiver.loc.expression.source
+                receiver.source
               else
                 'self'
               end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,10 +7,11 @@ module RuboCop
       # This is actually not a cop and inspects nothing. It just provides
       # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
       module Syntax
-        PseudoSourceRange = Struct.new(:line, :column, :source_line)
+        PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
+                                       :end_pos)
 
         COP_NAME = 'Syntax'.freeze
-        ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '').freeze
+        ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
 
         def self.offenses_from_processed_source(processed_source)
           offenses = []
@@ -19,17 +21,19 @@ module RuboCop
           end
 
           processed_source.diagnostics.each do |diagnostic|
-            offenses << offense_from_diagnostic(diagnostic)
+            offenses << offense_from_diagnostic(diagnostic,
+                                                processed_source.ruby_version)
           end
 
           offenses
         end
 
-        def self.offense_from_diagnostic(diagnostic)
+        def self.offense_from_diagnostic(diagnostic, ruby_version)
           Offense.new(
             diagnostic.level,
             diagnostic.location,
-            diagnostic.message,
+            "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
+            'configure using `TargetRubyVersion` parameter, under `AllCops`)',
             COP_NAME
           )
         end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks for underscore-prefixed variables that are actually
       # used.
       class UnderscorePrefixedVariableName < Cop
-        MSG = 'Do not use prefix `_` for a variable that is used.'
+        MSG = 'Do not use prefix `_` for a variable that is used.'.freeze
 
         def join_force?(force_class)
           force_class == VariableForce
@@ -26,7 +27,7 @@ module RuboCop
           node = variable.declaration_node
 
           location = if node.type == :match_with_lvasgn
-                       node.children.first.loc.expression
+                       node.children.first.source_range
                      else
                        node.loc.name
                      end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,59 +14,161 @@ module RuboCop
       # execution. The reason it can't be implemented as a normal cop is that
       # it depends on the results of all other cops to do its work.
       class UnneededDisable < Cop
-        COP_NAME = 'Lint/UnneededDisable'
+        include NameSimilarity
+
+        COP_NAME = 'Lint/UnneededDisable'.freeze
 
         def check(offenses, cop_disabled_line_ranges, comments)
-          unneeded_cops = {}
+          unneeded_cops = Hash.new { |h, k| h[k] = Set.new }
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
-            cop_offenses = offenses.select { |o| o.cop_name == cop }
+            line_ranges.each_cons(2) do |previous_range, range|
+              next if previous_range.end != range.begin
+
+              # If a cop is disabled in a range that begins on the same line as
+              # the end of the previous range, it means that the cop was
+              # already disabled by an earlier comment. So it's unneeded
+              # whether there are offenses or not.
+              comment = comments.find { |c| c.loc.line == range.begin }
+              unneeded_cops[comment].add(cop)
+            end
+
             line_ranges.each do |line_range|
               comment = comments.find { |c| c.loc.line == line_range.begin }
-              unneeded_cop = find_unneeded(comment, offenses, cop, cop_offenses,
-                                           line_range)
 
               unless all_disabled?(comment)
                 next if ignore_offense?(disabled_ranges, line_range)
               end
 
-              if unneeded_cop
-                unneeded_cops[comment.loc.expression] ||= Set.new
-                unneeded_cops[comment.loc.expression].add(unneeded_cop)
-              end
+              unneeded_cop = find_unneeded(comment, offenses, cop, line_range)
+              unneeded_cops[comment].add(unneeded_cop) if unneeded_cop
             end
           end
 
           add_offenses(unneeded_cops)
         end
 
+        def autocorrect(args)
+          lambda do |corrector|
+            ranges, range = *args # ranges are sorted by position
+
+            if range.source.start_with?('#')
+              # eat the entire comment and following newline
+              corrector.remove(range_with_surrounding_space(range, :right))
+            else
+              # is there any cop between this one and the end of the line, which
+              # is NOT being removed?
+
+              if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
+                # eat the comma on the left
+                range = range_with_surrounding_space(range, :left)
+                range = range_with_surrounding_comma(range, :left)
+              end
+
+              range = range_with_surrounding_comma(range, :right)
+              # eat following spaces up to EOL, but not the newline itself
+              range = range_with_surrounding_space(range, :right, nil, false)
+
+              corrector.remove(range)
+            end
+          end
+        end
+
         private
 
-        def find_unneeded(comment, offenses, cop, cop_offenses, line_range)
+        def find_unneeded(comment, offenses, cop, line_range)
           if all_disabled?(comment)
-            'all cops' if offenses.none? { |o| line_range.include?(o.line) }
-          elsif cop_offenses.none? { |o| line_range.include?(o.line) }
-            cop
+            'all' if offenses.none? { |o| line_range.cover?(o.line) }
+          else
+            cop_offenses = offenses.select { |o| o.cop_name == cop }
+            cop if cop_offenses.none? { |o| line_range.cover?(o.line) }
           end
         end
 
         def all_disabled?(comment)
-          comment.loc.expression.source =~ /rubocop:disable\s+all\b/
+          comment.text =~ /rubocop:disable\s+all\b/
         end
 
         def ignore_offense?(disabled_ranges, line_range)
           disabled_ranges.any? do |range|
-            range.include?(line_range.min) && range.include?(line_range.max)
+            range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def directive_count(comment)
+          match = comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+          _, cops_string = match.captures
+          cops_string.split(/,\s*/).size
+        end
+
         def add_offenses(unneeded_cops)
-          unneeded_cops.each do |range, cops|
-            add_offense(range, range,
-                        "Unnecessary disabling of #{cops.sort.join(', ')}.")
+          unneeded_cops.each do |comment, cops|
+            # Is the entire rubocop:disable line useless, or should just
+            # some of the mentioned cops be removed?
+            if all_disabled?(comment) ||
+               directive_count(comment) == cops.size
+              location = comment.loc.expression
+              cop_list = cops.sort.map { |c| describe(c) }
+              add_offense([[location], location], location,
+                          "Unnecessary disabling of #{cop_list.join(', ')}.")
+            else
+              cop_ranges = cops.map { |c| [c, cop_range(comment, c)] }
+              cop_ranges.sort_by! { |_, r| r.begin_pos }
+              ranges = cop_ranges.map { |_, r| r }
+
+              cop_ranges.each do |cop, range|
+                add_offense([ranges, range], range,
+                            "Unnecessary disabling of #{describe(cop)}.")
+              end
+            end
           end
         end
+
+        def cop_range(comment, cop)
+          matching_range(comment.loc.expression, cop) ||
+            matching_range(comment.loc.expression, cop.split('/').last) ||
+            fail("Couldn't find #{cop} in comment: #{comment.text}")
+        end
+
+        def matching_range(haystack, needle)
+          offset = (haystack.source =~ Regexp.new(Regexp.escape(needle)))
+          return unless offset
+          offset += haystack.begin_pos
+          Parser::Source::Range.new(haystack.source_buffer, offset,
+                                    offset + needle.size)
+        end
+
+        def trailing_range?(ranges, range)
+          ranges
+            .drop_while { |r| !r.equal?(range) }
+            .each_cons(2)
+            .map { |r1, r2| r1.end.join(r2.begin).source }
+            .all? { |intervening| intervening =~ /\A\s*,\s*\Z/ }
+        end
+
+        def describe(cop)
+          if cop == 'all'
+            'all cops'
+          elsif all_cop_names.include?(cop)
+            "`#{cop}`"
+          else
+            similar = find_similar_name(cop, [])
+            if similar
+              "`#{cop}` (did you mean `#{similar}`?)"
+            else
+              "`#{cop}` (unknown cop)"
+            end
+          end
+        end
+
+        def collect_variable_like_names(scope)
+          all_cop_names.each { |name| scope << name }
+        end
+
+        def all_cop_names
+          @all_cop_names ||= Cop.all.map(&:cop_name)
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,10 +8,10 @@ module RuboCop
       # The check are based on the presence of flow of control
       # statement in non-final position in *begin*(implicit) blocks.
       class UnreachableCode < Cop
-        MSG = 'Unreachable code detected.'
+        MSG = 'Unreachable code detected.'.freeze
 
-        NODE_TYPES = [:return, :next, :break, :retry, :redo]
-        FLOW_COMMANDS = [:throw, :raise, :fail]
+        NODE_TYPES = [:return, :next, :break, :retry, :redo].freeze
+        FLOW_COMMANDS = [:throw, :raise, :fail].freeze
 
         def on_begin(node)
           expressions = *node
@@ -24,7 +25,7 @@ module RuboCop
         private
 
         def flow_command?(node)
-          FLOW_COMMANDS.any? { |c| command?(c, node) }
+          FLOW_COMMANDS.any? { |c| node.command?(c) }
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -26,7 +27,8 @@ module RuboCop
         end
 
         def message(variable)
-          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
+          message = String.new("Unused #{variable_type(variable)} - " \
+                               "`#{variable.name}`.")
 
           return message if variable.explicit_block_local_variable?
 
@@ -35,11 +37,11 @@ module RuboCop
           scope = variable.scope
           all_arguments = scope.variables.each_value.select(&:block_argument?)
 
-          if lambda?(scope.node)
-            message << message_for_lambda(variable, all_arguments)
-          else
-            message << message_for_normal_block(variable, all_arguments)
-          end
+          message << if scope.node.lambda?
+                       message_for_lambda(variable, all_arguments)
+                     else
+                       message_for_normal_block(variable, all_arguments)
+                     end
 
           message
         end
@@ -65,7 +67,7 @@ module RuboCop
         end
 
         def message_for_lambda(variable, all_arguments)
-          message = message_for_underscore_prefix(variable)
+          message = String.new(message_for_underscore_prefix(variable))
 
           if all_arguments.none?(&:referenced?)
             message << ' Also consider using a proc without arguments ' \

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -27,7 +28,7 @@ module RuboCop
         end
 
         def message(variable)
-          message = "Unused method argument - `#{variable.name}`."
+          message = String.new("Unused method argument - `#{variable.name}`.")
 
           unless variable.keyword_argument?
             message << " If it's necessary, use `_` or `_#{variable.name}` " \

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

@@ -1,56 +1,83 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for access modifiers without any code.
+      # This cop checks for redundant access modifiers, including those with
+      # no code, those which are repeated, and leading `public` modifiers in
+      # a class or module body.
       #
       # @example
+      #
       #   class Foo
-      #     private # This is useless
+      #     public # this is redundant
+      #
+      #     def method
+      #     end
       #
-      #     def self.some_method
+      #     private # this is not redundant
+      #     def method2
       #     end
+      #
+      #     private # this is redundant
       #   end
       class UselessAccessModifier < Cop
-        include AccessModifierNode
-
-        MSG = 'Useless `%s` access modifier.'
+        MSG = 'Useless `%s` access modifier.'.freeze
 
-        def on_class(node)
-          _name, _base_class, body = *node
-          return unless body
+        def_node_matcher :access_modifier, <<-PATTERN
+          (send nil ${:public :protected :private})
+        PATTERN
 
-          body_nodes = body.type == :begin ? body.children : [body]
+        def_node_matcher :method_definition?, <<-PATTERN
+          {def (send nil {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+        PATTERN
 
-          body_nodes.each do |child_node|
-            check_for_access_modifier(child_node) ||
-              check_for_instance_method(child_node)
-          end
+        def on_class(node)
+          check_node(node.children[2]) # class body
+        end
 
-          add_offense_for_access_modifier
+        def on_module(node)
+          check_node(node.children[1]) # module body
         end
 
         private
 
-        def add_offense_for_access_modifier
-          return unless @access_modifier_node
-
-          _, modifier = *@access_modifier_node
-          message = format(MSG, modifier)
-          add_offense(@access_modifier_node, :expression, message)
+        def check_node(node)
+          return if node.nil?
+          if node.begin_type?
+            check_scope(node)
+          elsif (vis = access_modifier(node))
+            add_offense(node, :expression, format(MSG, vis))
+          end
         end
 
-        def check_for_instance_method(node)
-          return unless node.type == :def || node.type == :send
+        def check_scope(node, cur_vis = :public)
+          unused = nil
 
-          @access_modifier_node = nil
-        end
+          node.children.each do |child|
+            if (new_vis = access_modifier(child))
+              # does this modifier just repeat the existing visibility?
+              if new_vis == cur_vis
+                add_offense(child, :expression, format(MSG, cur_vis))
+              else
+                # was the previous modifier never applied to any defs?
+                add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+                # once we have already warned about a certain modifier, don't
+                # warn again even if it is never applied to any method defs
+                unused = child
+              end
+              cur_vis = new_vis
+            elsif method_definition?(child)
+              unused = nil
+            elsif child.kwbegin_type?
+              cur_vis = check_scope(child, cur_vis)
+            end
+          end
 
-        def check_for_access_modifier(node)
-          return unless modifier_node?(node)
+          add_offense(unused, :expression, format(MSG, cur_vis)) if unused
 
-          add_offense_for_access_modifier
-          @access_modifier_node = node
+          cur_vis
         end
       end
     end