rubocop 1.5.2 → 1.8.1

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -36,12 +36,13 @@ module RuboCop
       #     spec.required_ruby_version = '>= 2.5'
       #   end
       #
-      #   # good
+      #   # accepted but not recommended
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = ['>= 2.5.0', '< 2.7.0']
       #   end
       #
-      #   # good
+      #   # accepted but not recommended, since
+      #   # Ruby does not really follow semantic versionning
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = '~> 2.5'
       #   end

data/lib/rubocop/cop/internal_affairs.rb

@@ -6,4 +6,5 @@ require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/offense_location_keyword'
 require_relative 'internal_affairs/redundant_message_argument'
 require_relative 'internal_affairs/redundant_location_argument'
+require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/useless_message_assertion'

data/lib/rubocop/cop/internal_affairs/style_detected_api_use.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for correct use of the style_detected API provided by
+      # `ConfigurableEnforcedStyle`. If `correct_style_detected` is used
+      # then `opposite_style_detected`, `unexpected_style_detected`,
+      # `ambiguous_style_detected`, `conflicting_styles_detected`,
+      # `unrecognized_style_detected` or `no_acceptable_style!` should be
+      # used too, and vice versa.  The `xxx_style_detected` methods
+      # should not be used as predicates either.
+      #
+      # @example
+      #
+      #   # bad
+      #   def on_send(node)
+      #     return add_offense(node) if opposite_style_detected
+      #
+      #     correct_style_detected
+      #   end
+      #
+      #   def on_send(node)
+      #     if offense?
+      #       add_offense(node)
+      #     else
+      #       correct_style_detected
+      #     end
+      #   end
+      #
+      #   def on_send(node)
+      #     return unless offense?
+      #
+      #     add_offense(node)
+      #     opposite_style_detected
+      #   end
+      #
+      #   # good
+      #   def on_send(node)
+      #     if offense?
+      #       add_offense(node)
+      #       opposite_style_detected
+      #     else
+      #       correct_style_detected
+      #     end
+      #   end
+      #
+      #   def on_send(node)
+      #     add_offense(node) if offense?
+      #   end
+      #
+      class StyleDetectedApiUse < Base
+        include RangeHelp
+
+        MSG_FOR_POSITIVE_WITHOUT_NEGATIVE =
+          '`correct_style_detected` method called without ' \
+          'calling a negative `*_style_detected` method.'
+        MSG_FOR_NEGATIVE_WITHOUT_POSITIVE =
+          'negative `*_style_detected` methods called without ' \
+          'calling `correct_style_detected` method.'
+        MSG_FOR_CONDITIONAL_USE =
+          '`*_style_detected` method called in conditional.'
+        RESTRICT_ON_SEND = %i[
+          correct_style_detected opposite_style_detected
+          unexpected_style_detected ambiguous_style_detected
+          conflicting_styles_detected unrecognized_style_detected
+          no_acceptable_style! style_detected
+        ].freeze
+
+        def_node_matcher :correct_style_detected_check, <<~PATTERN
+          (send nil? :correct_style_detected)
+        PATTERN
+
+        def_node_matcher :negative_style_detected_method_check, <<~PATTERN
+          (send nil? /(?:opposite|unexpected|ambiguous|unrecognized)_style_detected|conflicting_styles_detected/ ...)
+        PATTERN
+
+        def_node_matcher :no_acceptable_style_check, <<~PATTERN
+          (send nil? :no_acceptable_style!)
+        PATTERN
+
+        def_node_matcher :style_detected_check, <<~PATTERN
+          (send nil? :style_detected ...)
+        PATTERN
+
+        def on_new_investigation
+          @correct_style_detected_called = false
+          @negative_style_detected_methods_called = false
+          @style_detected_called = false
+        end
+
+        def on_investigation_end
+          return if style_detected_called
+          return unless correct_style_detected_called ^ negative_style_detected_methods_called
+
+          add_global_offense(MSG_FOR_POSITIVE_WITHOUT_NEGATIVE) if positive_without_negative?
+          add_global_offense(MSG_FOR_NEGATIVE_WITHOUT_POSITIVE) if negative_without_positive?
+        end
+
+        def on_send(node)
+          if correct_style_detected_check(node)
+            @correct_style_detected_called = true
+          elsif negative_style_detected_method_check(node) || no_acceptable_style_check(node)
+            @negative_style_detected_methods_called = true
+          elsif style_detected_check(node)
+            @style_detected_called = true
+          end
+        end
+
+        def on_if(node)
+          traverse_condition(node.condition) do |cond|
+            add_offense(cond, message: MSG_FOR_CONDITIONAL_USE) if style_detected_api_used?(cond)
+          end
+        end
+
+        private
+
+        attr_reader :correct_style_detected_called,
+                    :negative_style_detected_methods_called,
+                    :style_detected_called
+
+        def positive_without_negative?
+          correct_style_detected_called && !negative_style_detected_methods_called
+        end
+
+        def negative_without_positive?
+          negative_style_detected_methods_called && !correct_style_detected_called
+        end
+
+        def style_detected_api_used?(node)
+          correct_style_detected_check(node) ||
+            negative_style_detected_method_check(node) ||
+            no_acceptable_style_check(node) ||
+            style_detected_check(node)
+        end
+
+        def traverse_condition(condition, &block)
+          yield condition if condition.send_type?
+
+          condition.each_child_node { |child| traverse_condition(child, &block) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -76,6 +76,14 @@ module RuboCop
       #
       #   def b
       #   end
+      #
+      # @example AllowAdjacentOneLineDefs: true
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #   class ErrorC < BaseError; end
+      #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector
@@ -113,8 +121,8 @@ module RuboCop
 
         def autocorrect(corrector, prev_def, node)
           # finds position of first newline
-          end_pos = prev_def.loc.end.end_pos
-          source_buffer = prev_def.loc.end.source_buffer
+          end_pos = end_loc(prev_def).end_pos
+          source_buffer = end_loc(prev_def).source_buffer
           newline_pos = source_buffer.source.index("\n", end_pos)
 
           # Handle the case when multiple one-liners are on the same line.
@@ -198,7 +206,15 @@ module RuboCop
         end
 
         def def_end(node)
-          node.loc.end.line
+          end_loc(node).line
+        end
+
+        def end_loc(node)
+          if (node.def_type? || node.defs_type?) && node.endless?
+            node.loc.expression.end
+          else
+            node.loc.end
+          end
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)

data/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb

@@ -84,7 +84,7 @@ module RuboCop
         private
 
         def next_line_empty?(line)
-          processed_source[line].blank?
+          processed_source[line].nil? || processed_source[line].blank?
         end
 
         def require_empty_line?(node)

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -70,6 +70,7 @@ module RuboCop
           return unless outermost_send.loc.end
           return unless heredoc_arg.first_line != outermost_send.loc.end.line
           return if subsequent_closing_parentheses_in_same_line?(outermost_send)
+          return if exist_argument_between_heredoc_end_and_closing_parentheses?(node)
 
           add_offense(outermost_send.loc.end) do |corrector|
             autocorrect(corrector, outermost_send)
@@ -215,6 +216,19 @@ module RuboCop
           end
         end
 
+        def exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+          return false unless (heredoc_end = find_most_bottom_of_heredoc_end(node.arguments))
+
+          heredoc_end < node.loc.end.begin_pos &&
+            range_between(heredoc_end, node.loc.end.begin_pos).source.strip != ''
+        end
+
+        def find_most_bottom_of_heredoc_end(arguments)
+          arguments.map do |argument|
+            argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
+          end.compact.max
+        end
+
         # Internal trailing comma helpers.
 
         def remove_internal_trailing_comma(node, corrector)

data/lib/rubocop/cop/layout/line_length.rb

@@ -58,12 +58,13 @@ module RuboCop
       #     bar: "0000000000",
       #     baz: "0000000000",
       #   }
-      class LineLength < Cop
+      class LineLength < Base
         include CheckLineBreakable
         include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
         include LineLengthHelp
+        extend AutoCorrector
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
@@ -78,28 +79,16 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
 
-        def investigate(processed_source)
+        def on_new_investigation
           check_for_breakable_semicolons(processed_source)
         end
 
-        def investigate_post_walk(processed_source)
+        def on_investigation_end
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
           end
         end
 
-        def correctable?
-          super && !breakable_range.nil?
-        end
-
-        def autocorrect(range)
-          return if range.nil?
-
-          lambda do |corrector|
-            corrector.insert_before(range, "\n")
-          end
-        end
-
         private
 
         attr_accessor :breakable_range
@@ -203,8 +192,9 @@ module RuboCop
 
           self.breakable_range = breakable_range_by_line_index[line_index]
 
-          add_offense(breakable_range, location: loc, message: message) do
+          add_offense(loc, message: message) do |corrector|
             self.max = line_length(line)
+            corrector.insert_before(breakable_range, "\n") unless breakable_range.nil?
           end
         end
 

data/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -16,14 +16,14 @@ module RuboCop
       #   if a +
       #       b
       #     something &&
-      #     something_else
+      #       something_else
       #   end
       #
       #   # good
       #   if a +
       #      b
       #     something &&
-      #       something_else
+      #     something_else
       #   end
       #
       # @example EnforcedStyle: indented

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -191,16 +191,9 @@ module RuboCop
         end
 
         def begin_end_alignment_style
-          # FIXME: Workaround for pending status for `Layout/BeginEndAlignment` cop
-          #        When RuboCop 1.0 is released, please replace it with the following condition.
-          #
-          # config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
-          #   config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
-          if config.for_all_cops['NewCops'] == 'enable' ||
-             config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
-             config.for_cop('Layout/BeginEndAlignment')['Enabled'] != 'pending'
-            config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
-          end
+          begin_end_alignment_conf = config.for_cop('Layout/BeginEndAlignment')
+
+          begin_end_alignment_conf['Enabled'] && begin_end_alignment_conf['EnforcedStyleAlignWith']
         end
       end
     end

data/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb

@@ -60,6 +60,7 @@ module RuboCop
 
           add_offense(range) do |corrector|
             autocorrect(corrector, range)
+            opposite_style_detected
           end
         end
 

data/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -106,6 +106,7 @@ module RuboCop
         def space_missing(left_brace)
           add_offense(left_brace, message: MISSING_MSG) do |corrector|
             autocorrect(corrector, left_brace)
+            opposite_style_detected
           end
         end
 
@@ -114,6 +115,7 @@ module RuboCop
 
           add_offense(space, message: DETECTED_MSG) do |corrector|
             autocorrect(corrector, space)
+            opposite_style_detected
           end
         end
 

data/lib/rubocop/cop/layout/space_before_brackets.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for space between the name of a receiver and a left
+      # brackets.
+      #
+      # @example
+      #
+      #   # bad
+      #   collection [index_or_key]
+      #
+      #   # good
+      #   collection[index_or_key]
+      #
+      class SpaceBeforeBrackets < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the space before the opening brackets.'
+
+        def on_send(node)
+          return unless (first_argument = node.first_argument)
+
+          begin_pos = first_argument.source_range.begin_pos
+          return unless (range = offense_range(node, begin_pos))
+
+          register_offense(range)
+        end
+
+        private
+
+        def offense_range(node, begin_pos)
+          if reference_variable_with_brackets?(node)
+            receiver_end_pos = node.receiver.source_range.end_pos
+            selector_begin_pos = node.loc.selector.begin_pos
+            return if receiver_end_pos >= selector_begin_pos
+
+            range_between(receiver_end_pos, selector_begin_pos)
+          elsif node.method?(:[]=)
+            end_pos = node.receiver.source_range.end_pos
+
+            return if begin_pos - end_pos == 1
+
+            range_between(end_pos, begin_pos - 1)
+          end
+        end
+
+        def register_offense(range)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def reference_variable_with_brackets?(node)
+          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -111,7 +111,8 @@ module RuboCop
               braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
               offense(range.begin_pos, range.end_pos,
-                      'Space inside empty braces detected.')
+                      'Space inside empty braces detected.',
+                      'EnforcedStyleForEmptyBraces')
             end
           end
         end
@@ -120,7 +121,8 @@ module RuboCop
           return if style_for_empty_braces != :space
 
           offense(left_brace.begin_pos, right_brace.end_pos,
-                  'Space missing inside empty braces.')
+                  'Space missing inside empty braces.',
+                  'EnforcedStyleForEmptyBraces')
         end
 
         def braces_with_contents_inside(node, inner)
@@ -164,9 +166,9 @@ module RuboCop
             if left_brace.end_pos == args_delimiter.begin_pos &&
                cop_config['SpaceBeforeBlockParameters']
               offense(left_brace.begin_pos, args_delimiter.end_pos,
-                      'Space between { and | missing.') do
-                opposite_style_detected
-              end
+                      'Space between { and | missing.')
+            else
+              correct_style_detected
             end
           else
             # We indicate the position after the left brace. Otherwise it's
@@ -179,11 +181,11 @@ module RuboCop
 
         def space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
-            unless cop_config['SpaceBeforeBlockParameters']
+            if cop_config['SpaceBeforeBlockParameters']
+              correct_style_detected
+            else
               offense(left_brace.end_pos, args_delimiter.begin_pos,
-                      'Space between { and | detected.') do
-                opposite_style_detected
-              end
+                      'Space between { and | detected.')
             end
           else
             brace_with_space = range_with_surrounding_space(range: left_brace,
@@ -220,7 +222,7 @@ module RuboCop
           end
         end
 
-        def offense(begin_pos, end_pos, msg)
+        def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|
             case range.source
@@ -229,6 +231,7 @@ module RuboCop
             when '{|' then corrector.replace(range, '{ |')
             else           corrector.insert_before(range, ' ')
             end
+            opposite_style_detected if style_param == 'EnforcedStyle'
           end
         end