rubocop 0.47.1 → 0.48.0

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

@@ -4,7 +4,31 @@ module RuboCop
   module Cop
     module Style
       # This cop checks whether method definitions are
-      # separated by empty lines.
+      # separated by one empty line.
+      #
+      # `NumberOfEmptyLines` can be and integer (e.g. 1 by default) or
+      # an array (e.g. [1, 2]) to specificy a minimum and a maximum of
+      # empty lines.
+      #
+      # `AllowAdjacentOneLineDefs` can be used to configure is adjacent
+      # one line methods definitions are an offense
+      #
+      # @example
+      #
+      #   # bad
+      #   def a
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def a
+      #   end
+      #
+      #   def b
+      #   end
       class EmptyLineBetweenDefs < Cop
         MSG = 'Use empty lines between method definitions.'.freeze
 
@@ -22,6 +46,7 @@ module RuboCop
 
         def check_defs(nodes)
           return if blank_lines_between?(*nodes)
+          return if multiple_blank_lines_groups?(*nodes)
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
@@ -35,8 +60,29 @@ module RuboCop
           node.def_type? || node.defs_type?
         end
 
+        def multiple_blank_lines_groups?(first_def_node, second_def_node)
+          lines = lines_between_defs(first_def_node, second_def_node)
+          blank_start = lines.each_index.select { |i| lines[i].blank? }.max
+          non_blank_end = lines.each_index.reject { |i| lines[i].blank? }.min
+          return false if blank_start.nil? || non_blank_end.nil?
+          blank_start > non_blank_end
+        end
+
         def blank_lines_between?(first_def_node, second_def_node)
-          lines_between_defs(first_def_node, second_def_node).any?(&:blank?)
+          count = blank_lines_count_between(first_def_node, second_def_node)
+          (minimum_empty_lines..maximum_empty_lines).cover?(count)
+        end
+
+        def blank_lines_count_between(first_def_node, second_def_node)
+          lines_between_defs(first_def_node, second_def_node).count(&:blank?)
+        end
+
+        def minimum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).first
+        end
+
+        def maximum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).last
         end
 
         def prev_node(node)
@@ -61,11 +107,35 @@ module RuboCop
 
         def autocorrect(node)
           prev_def = prev_node(node)
+
+          # finds position of first newline
           end_pos = prev_def.loc.end.end_pos
           source_buffer = prev_def.loc.end.source_buffer
           newline_pos = source_buffer.source.index("\n", end_pos)
-          newline = range_between(newline_pos, newline_pos + 1)
-          ->(corrector) { corrector.insert_after(newline, "\n") }
+
+          count = blank_lines_count_between(prev_def, node)
+
+          if count > maximum_empty_lines
+            autocorrect_remove_lines(newline_pos, count)
+          else
+            autocorrect_insert_lines(newline_pos, count)
+          end
+        end
+
+        def autocorrect_remove_lines(newline_pos, count)
+          difference = count - maximum_empty_lines
+          range_to_remove = range_between(newline_pos, newline_pos + difference)
+          lambda do |corrector|
+            corrector.remove(range_to_remove)
+          end
+        end
+
+        def autocorrect_insert_lines(newline_pos, count)
+          difference = minimum_empty_lines - count
+          where_to_insert = range_between(newline_pos, newline_pos + 1)
+          lambda do |corrector|
+            corrector.insert_after(where_to_insert, "\n" * difference)
+          end
         end
       end
     end

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

@@ -0,0 +1,42 @@
+
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks if empty lines exist around the bodies of begin-end
+      # blocks.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     ...
+      #   end
+      #
+      #   # bad
+      #
+      #   begin
+      #
+      #     ...
+      #
+      #   end
+      class EmptyLinesAroundBeginBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = '`begin`'.freeze
+
+        def on_kwbegin(node)
+          check(node, nil)
+        end
+
+        private
+
+        def style
+          :no_empty_lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks if empty lines exist around the bodies of `begin`
+      # sections. This cop doesn't check empty lines at `begin` body
+      # beginning/end and around method definition body.
+      # `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody`
+      # can be used for this purpose.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   else
+      #     do_something3
+      #   ensure
+      #     do_something4
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   end
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #
+      #   else
+      #
+      #     do_something3
+      #
+      #   ensure
+      #
+      #     do_something4
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #   end
+      class EmptyLinesAroundExceptionHandlingKeywords < Cop
+        include EmptyLinesAroundBody
+        include OnMethodDef
+
+        MSG = 'Extra empty line detected %s the `%s`.'.freeze
+
+        def on_method_def(_node, _method_name, _args, body)
+          check_body(body)
+        end
+
+        def on_kwbegin(node)
+          body, = *node
+          check_body(body)
+        end
+
+        private
+
+        def check_body(node)
+          locations = keyword_locations(node)
+          locations.each do |loc|
+            line = loc.line
+            keyword = loc.source
+            # below the keyword
+            check_line(style, line, format(MSG, 'after', keyword), &:empty?)
+            # above the keyword
+            check_line(style,
+                       line - 2,
+                       format(MSG, 'before', keyword),
+                       &:empty?)
+          end
+        end
+
+        def style
+          :no_empty_lines
+        end
+
+        def keyword_locations(node)
+          return [] unless node
+          case node.type
+          when :rescue
+            keyword_locations_in_rescue(node)
+          when :ensure
+            keyword_locations_in_ensure(node)
+          else
+            []
+          end
+        end
+
+        def keyword_locations_in_rescue(node)
+          _begin_body, *resbodies, _else_body = *node
+          [
+            node.loc.else,
+            *resbodies.map { |body| body.loc.keyword }
+          ].compact
+        end
+
+        def keyword_locations_in_ensure(node)
+          ensure_body, = *node
+          [
+            node.loc.keyword,
+            *keyword_locations(ensure_body)
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -15,16 +15,15 @@ module RuboCop
         def_node_matcher :array_node, '(send (const nil :Array) :new)'
         def_node_matcher :hash_node, '(send (const nil :Hash) :new)'
         def_node_matcher :str_node, '(send (const nil :String) :new)'
+        def_node_matcher :array_with_block,
+                         '(block (send (const nil :Array) :new) args _)'
+        def_node_matcher :hash_with_block,
+                         '(block (send (const nil :Hash) :new) args _)'
 
         def on_send(node)
-          array_node(node) { add_offense(node, :expression, ARR_MSG) }
+          add_offense(node, :expression, ARR_MSG) if offense_array_node?(node)
 
-          hash_node(node) do
-            # If Hash.new takes a block, it can't be changed to {}.
-            return if node.parent && node.parent.block_type?
-
-            add_offense(node, :expression, HASH_MSG)
-          end
+          add_offense(node, :expression, HASH_MSG) if offense_hash_node?(node)
 
           str_node(node) do
             return if frozen_string_literals_enabled?
@@ -77,12 +76,21 @@ module RuboCop
           end
         end
 
+        def offense_array_node?(node)
+          array_node(node) && !array_with_block(node.parent)
+        end
+
+        def offense_hash_node?(node)
+          # If Hash.new takes a block, it can't be changed to {}.
+          hash_node(node) && !hash_with_block(node.parent)
+        end
+
         def correction(node)
-          if array_node(node)
+          if offense_array_node?(node)
             '[]'
           elsif str_node(node)
             preferred_string_literal
-          elsif hash_node(node)
+          elsif offense_hash_node?(node)
             if first_argument_unparenthesized?(node)
               # `some_method {}` is not same as `some_method Hash.new`
               # because the braces are interpreted as a block. We will have

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

@@ -5,7 +5,10 @@ module RuboCop
     module Style
       # This cop checks for Windows-style line endings in the source code.
       class EndOfLine < Cop
-        MSG = 'Carriage return character detected.'.freeze
+        include ConfigurableEnforcedStyle
+
+        MSG_DETECTED = 'Carriage return character detected.'.freeze
+        MSG_MISSING = 'Carriage return character missing.'.freeze
 
         def investigate(processed_source)
           last_token = processed_source.tokens.last
@@ -14,16 +17,35 @@ module RuboCop
 
           processed_source.raw_source.each_line.with_index do |line, index|
             break if index >= last_line
-            next unless line =~ /\r$/
+            msg = offense_message(line)
+            next unless msg
+            next if unimportant_missing_cr?(index, last_line, line)
 
             range =
               source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, range, MSG)
+            add_offense(nil, range, msg)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break
           end
         end
+
+        # If there is no LF on the last line, we don't care if there's no CR.
+        def unimportant_missing_cr?(index, last_line, line)
+          style == :crlf && index == last_line - 1 && line !~ /\n$/
+        end
+
+        def offense_message(line)
+          effective_style = if style == :native
+                              Platform.windows? ? :crlf : :lf
+                            else
+                              style
+                            end
+          case effective_style
+          when :lf then MSG_DETECTED if line =~ /\r$/
+          else MSG_MISSING if line !~ /\r$/
+          end
+        end
       end
     end
   end

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

@@ -91,7 +91,7 @@ module RuboCop
           return nil if node.nil?
           name = namespace.pop
 
-          on_node([:class, :module, :casgn], node) do |child|
+          on_node(%i(class module casgn), node) do |child|
             next unless (const = child.defined_module)
 
             const_namespace, const_name = *const

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

@@ -27,7 +27,7 @@ module RuboCop
               'multi-line method argument list.'.freeze
 
         def on_send(node)
-          _receiver, _name, *args = *node
+          args = node.arguments
 
           # If there is a trailing hash arg without explicit braces, like this:
           #

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

@@ -23,23 +23,17 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return if args.empty?
-          return if operator?(method_name)
-
-          base_indentation = if special_inner_call_indentation?(node)
-                               column_of(base_range(node, args.first))
-                             else
-                               previous_code_line(args.first.loc.line) =~ /\S/
-                             end
-          check_alignment([args.first],
-                          base_indentation + configured_indentation_width)
+          return if !node.arguments? || node.operator_method?
+
+          indent = base_indentation(node) + configured_indentation_width
+
+          check_alignment([node.first_argument], indent)
         end
 
         private
 
         def message(arg_node)
-          return 'Bad indentation of the first parameter.' if arg_node.nil?
+          return 'Bad indentation of the first parameter.' unless arg_node
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
@@ -53,18 +47,22 @@ module RuboCop
           format('Indent the first parameter one step more than %s.', base)
         end
 
+        def base_indentation(node)
+          if special_inner_call_indentation?(node)
+            column_of(base_range(node, node.first_argument))
+          else
+            previous_code_line(node.first_argument.loc.line) =~ /\S/
+          end
+        end
+
         def special_inner_call_indentation?(node)
           return false if style == :consistent
 
           parent = node.parent
-          return false unless parent
-          return false unless parent.send_type?
-
-          _receiver, method_name, *_args = *parent
-          # :[]= is a send node, but we want to treat it as an assignment.
-          return false if method_name == :[]=
 
-          return false if !parentheses?(parent) &&
+          return false unless parent && parent.send_type? &&
+                              !parent.method?(:[]=)
+          return false if !parent.parenthesized? &&
                           style == :special_for_inner_method_call_in_parentheses
 
           # The node must begin inside the parent, otherwise node is the first