rubocop 0.87.0 → 0.90.0

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

@@ -7,10 +7,11 @@ module RuboCop
     module SpaceAfterPunctuation
       MSG = 'Space missing after %<token>s.'
 
-      def investigate(processed_source)
+      def on_new_investigation
         each_missing_space(processed_source.tokens) do |token|
-          add_offense(token, location: token.pos,
-                             message: format(MSG, token: kind(token)))
+          add_offense(token.pos, message: format(MSG, token: kind(token))) do |corrector|
+            PunctuationCorrector.add_space(corrector, token)
+          end
         end
       end
 

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

@@ -9,10 +9,11 @@ module RuboCop
 
       MSG = 'Space found before %<token>s.'
 
-      def investigate(processed_source)
+      def on_new_investigation
         each_missing_space(processed_source.tokens) do |token, pos_before|
-          add_offense(pos_before, location: pos_before,
-                                  message: format(MSG, token: kind(token)))
+          add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
+            PunctuationCorrector.remove_space(corrector, pos_before)
+          end
         end
       end
 

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

@@ -17,16 +17,16 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? &&
-            processed_source.commented?(node.loc.end)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.line_with_comment?(node.loc.last_line)
       end
 
       def non_eligible_body?(body)
         body.nil? ||
           body.empty_source? ||
           body.begin_type? ||
-          processed_source.commented?(body.source_range)
+          processed_source.contains_comment?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -36,14 +36,43 @@ module RuboCop
       def modifier_fits_on_single_line?(node)
         return true unless max_line_length
 
-        length_in_modifier_form(node, node.condition) <= max_line_length
+        length_in_modifier_form(node) <= max_line_length
       end
 
-      def length_in_modifier_form(node, cond)
-        keyword = node.loc.keyword
-        indentation = keyword.source_line[/^\s*/]
-        line_length("#{indentation}#{node.body.source} #{keyword.source} " \
-                    "#{cond.source}")
+      def length_in_modifier_form(node)
+        keyword_element = node.loc.keyword
+        end_element = node.loc.end
+        code_before = keyword_element.source_line[0...keyword_element.column]
+        code_after = end_element.source_line[end_element.last_column..-1]
+        expression = to_modifier_form(node)
+        line_length("#{code_before}#{expression}#{code_after}")
+      end
+
+      def to_modifier_form(node)
+        expression = [node.body.source,
+                      node.keyword,
+                      node.condition.source].compact.join(' ')
+        parenthesized = parenthesize?(node) ? "(#{expression})" : expression
+        [parenthesized, first_line_comment(node)].compact.join(' ')
+      end
+
+      def first_line_comment(node)
+        comment =
+          processed_source.find_comment { |c| c.loc.line == node.loc.line }
+
+        comment ? comment.loc.expression.source : nil
+      end
+
+      def parenthesize?(node)
+        # Parenthesize corrected expression if changing to modifier-if form
+        # would change the meaning of the parent expression
+        # (due to the low operator precedence of modifier-if)
+        parent = node.parent
+        return false if parent.nil?
+        return true if parent.assignment? || parent.operator_keyword?
+        return true if %i[array pair].include?(parent.type)
+
+        node.parent.send_type?
       end
 
       def max_line_length

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

@@ -30,31 +30,6 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def index_of_first_token(node)
-        range = node.source_range
-        token_table[range.line][range.column]
-      end
-
-      def index_of_last_token(node)
-        range = node.source_range
-        table_row = token_table[range.last_line]
-        (0...range.last_column).reverse_each do |c|
-          ix = table_row[c]
-          return ix if ix
-        end
-      end
-
-      def token_table
-        @token_table ||= begin
-          table = {}
-          processed_source.tokens.each_with_index do |t, ix|
-            table[t.line] ||= {}
-            table[t.line][t.column] = ix
-          end
-          table
-        end
-      end
-
       def on_new_investigation
         @token_table = nil
         super
@@ -106,8 +81,11 @@ module RuboCop
 
       def space_offense(node, token, side, message, command)
         range = side_space_range(range: token.pos, side: side)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node) unless ignored_node?(node)
+
+          ignore_node(node)
+        end
       end
 
       def empty_offenses(node, left, right, message)
@@ -121,8 +99,9 @@ module RuboCop
       end
 
       def empty_offense(node, range, message, command)
-        add_offense(node, location: range,
-                          message: format(message, command: command))
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node)
+        end
       end
 
       def empty_brackets?(left_bracket_token, right_bracket_token)

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

@@ -74,10 +74,8 @@ module RuboCop
       end
 
       def inside_comment?(range, comma_offset)
-        processed_source.comments.any? do |comment|
-          comment_offset = comment.loc.expression.begin_pos - range.begin_pos
-          comment_offset >= 0 && comment_offset < comma_offset
-        end
+        comment = processed_source.comment_at_line(range.line)
+        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.
@@ -142,7 +140,9 @@ module RuboCop
           unit: format(kind, article: article) + extra_info.to_s
         )
 
-        add_offense(range, location: range, message: msg)
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
       end
 
       def put_comma(items, kind)
@@ -150,13 +150,11 @@ module RuboCop
         return if last_item.block_pass_type?
 
         range = autocorrect_range(last_item)
-        msg = format(
-          MSG,
-          command: 'Put a',
-          unit: format(kind, article: 'a multiline')
-        )
+        msg = format(MSG, command: 'Put a', unit: format(kind, article: 'a multiline'))
 
-        add_offense(range, location: range, message: msg)
+        add_offense(range, message: msg) do |corrector|
+          PunctuationCorrector.swap_comma(corrector, range)
+        end
       end
 
       def autocorrect_range(item)

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

@@ -41,8 +41,7 @@ module RuboCop
       end
 
       def case_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(CASE_MSG, name_type: name_type(node)))
+        add_offense(range, message: format(CASE_MSG, name_type: name_type(node)))
       end
 
       def uppercase?(name)
@@ -59,8 +58,7 @@ module RuboCop
       end
 
       def num_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(NUM_MSG, name_type: name_type(node)))
+        add_offense(range, message: format(NUM_MSG, name_type: name_type(node)))
       end
 
       def ends_with_num?(name)
@@ -68,10 +66,9 @@ module RuboCop
       end
 
       def length_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(LENGTH_MSG,
-                                          name_type: name_type(node).capitalize,
-                                          min: min_length))
+        message = format(LENGTH_MSG, name_type: name_type(node).capitalize, min: min_length)
+
+        add_offense(range, message: message)
       end
 
       def long_enough?(name)
@@ -86,11 +83,7 @@ module RuboCop
       end
 
       def forbidden_offense(node, range, name)
-        add_offense(
-          node,
-          location: range,
-          message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node))
-        )
+        add_offense(range, message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node)))
       end
 
       def allowed_names

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

@@ -7,10 +7,6 @@ module RuboCop
       module UnusedArgument
         extend NodePattern::Macros
 
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
         def after_leaving_scope(scope, _variable_table)
           scope.variables.each_value do |variable|
             check_argument(variable)
@@ -24,8 +20,10 @@ module RuboCop
           return if variable.referenced?
 
           message = message(variable)
-          add_offense(variable.declaration_node, location: :name,
-                                                 message: message)
+
+          add_offense(variable.declaration_node.loc.name, message: message) do |corrector|
+            autocorrect(corrector, variable.declaration_node)
+          end
         end
       end
     end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining node visibility.
+    module VisibilityHelp
+      extend NodePattern::Macros
+
+      VISIBILITY_SCOPES = %i[private protected public].freeze
+
+      private
+
+      def node_visibility(node)
+        scope = find_visibility_start(node)
+        scope&.method_name || :public
+      end
+
+      def find_visibility_start(node)
+        left_siblings_of(node)
+          .reverse
+          .find(&method(:visibility_block?))
+      end
+
+      # Navigate to find the last protected method
+      def find_visibility_end(node)
+        possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+        right = right_siblings_of(node)
+        right.find do |child_node|
+          possible_visibilities.include?(node_visibility(child_node))
+        end || right.last
+      end
+
+      def left_siblings_of(node)
+        siblings_of(node)[0, node.sibling_index]
+      end
+
+      def right_siblings_of(node)
+        siblings_of(node)[node.sibling_index..-1]
+      end
+
+      def siblings_of(node)
+        node.parent.children
+      end
+
+      def_node_matcher :visibility_block?, <<~PATTERN
+        (send nil? { :private :protected :public })
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -21,14 +21,16 @@ module RuboCop
       #   # good
       #   def attribute
       #   end
-      class AccessorMethodName < Cop
+      class AccessorMethodName < Base
         MSG_READER = 'Do not prefix reader method names with `get_`.'
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'
 
         def on_def(node)
           return unless bad_reader_name?(node) || bad_writer_name?(node)
 
-          add_offense(node, location: :name)
+          message = message(node)
+
+          add_offense(node.loc.name, message: message)
         end
         alias on_defs on_def
 

data/lib/rubocop/cop/naming/ascii_identifiers.rb

@@ -52,18 +52,18 @@ module RuboCop
       #
       #   FOÖ = "foo"
       #
-      class AsciiIdentifiers < Cop
+      class AsciiIdentifiers < Base
         include RangeHelp
 
         IDENTIFIER_MSG = 'Use only ascii symbols in identifiers.'
         CONSTANT_MSG   = 'Use only ascii symbols in constants.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.each_token do |token|
             next if !should_check?(token) || token.text.ascii_only?
 
             message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG
-            add_offense(token, location: first_offense_range(token), message: message)
+            add_offense(first_offense_range(token), message: message)
           end
         end
 

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -13,7 +13,7 @@ module RuboCop
       #
       #   # good
       #   def +(other); end
-      class BinaryOperatorParameterName < Cop
+      class BinaryOperatorParameterName < Base
         MSG = 'When defining the `%<opr>s` operator, ' \
               'name its argument `other`.'
 

data/lib/rubocop/cop/naming/block_parameter_name.rb

@@ -35,7 +35,7 @@ module RuboCop
       #   foo { |speed, distance| speed * distance }
       #
       #   baz { |age, height, gender| do_stuff(age, height, gender) }
-      class BlockParameterName < Cop
+      class BlockParameterName < Base
         include UncommunicativeName
 
         def on_block(node)

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -26,7 +26,7 @@ module RuboCop
       #   end
       #   class module_parent::MyModule
       #   end
-      class ClassAndModuleCamelCase < Cop
+      class ClassAndModuleCamelCase < Base
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
@@ -34,7 +34,7 @@ module RuboCop
           name = node.loc.name.source.gsub(allowed, '')
           return unless /_/.match?(name)
 
-          add_offense(node, location: :name)
+          add_offense(node.loc.name)
         end
         alias on_module on_class
       end

data/lib/rubocop/cop/naming/constant_name.rb

@@ -17,7 +17,7 @@ module RuboCop
       #
       #   # good
       #   INCH_IN_CM = 2.54
-      class ConstantName < Cop
+      class ConstantName < Base
         MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
         # Use POSIX character classes, so we allow accented characters rather
         # than just standard ASCII characters
@@ -47,7 +47,7 @@ module RuboCop
           return if allowed_assignment?(value)
           return if SNAKE_CASE.match?(const_name)
 
-          add_offense(node, location: :name)
+          add_offense(node.loc.name)
         end
 
         private

data/lib/rubocop/cop/naming/file_name.rb

@@ -24,7 +24,7 @@ module RuboCop
       #   lib/layout_manager.rb
       #
       #   anything/using_snake_case.rake
-      class FileName < Cop
+      class FileName < Base
         include RangeHelp
 
         MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) ' \
@@ -35,13 +35,13 @@ module RuboCop
 
         SNAKE_CASE = /^[\da-z_.?!]+$/.freeze
 
-        def investigate(processed_source)
+        def on_new_investigation
           file_path = processed_source.file_path
           return if config.file_to_exclude?(file_path) ||
                     config.allowed_camel_case_file?(file_path)
 
           for_bad_filename(file_path) do |range, msg|
-            add_offense(nil, location: range, message: msg)
+            add_offense(range, message: msg)
           end
         end
 

data/lib/rubocop/cop/naming/heredoc_delimiter_case.rb

@@ -27,7 +27,7 @@ module RuboCop
       #   <<-sql
       #     SELECT * FROM foo
       #   sql
-      class HeredocDelimiterCase < Cop
+      class HeredocDelimiterCase < Base
         include Heredoc
         include ConfigurableEnforcedStyle
 
@@ -36,7 +36,7 @@ module RuboCop
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
 
-          add_offense(node, location: :heredoc_end)
+          add_offense(node.loc.heredoc_end)
         end
 
         private