rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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
+
+        MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'.freeze
+
+        def on_def(node)
+          check_body(node.body)
+        end
+        alias on_defs on_def
+
+        def on_kwbegin(node)
+          body, = *node
+          check_body(body)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        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, message('after', keyword), &:empty?)
+            # above the keyword
+            check_line(style,
+                       line - 2,
+                       message('before', keyword),
+                       &:empty?)
+          end
+        end
+
+        def message(location, keyword)
+          format(MSG, location: location, keyword: keyword)
+        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 → layout}/empty_lines_around_method_body.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks if empty lines exist around the bodies of methods.
       #
       # @example
@@ -11,24 +10,28 @@ module RuboCop
       #   # good
       #
       #   def foo
-      #     ...
+      #     # ...
       #   end
       #
       #   # bad
       #
       #   def bar
       #
-      #     ...
+      #     # ...
       #
       #   end
       class EmptyLinesAroundMethodBody < Cop
         include EmptyLinesAroundBody
-        include OnMethodDef
 
         KIND = 'method'.freeze
 
-        def on_method_def(node, _method_name, _args, body)
-          check(node, body)
+        def on_def(node)
+          check(node, node.body)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
         end
 
         private

data/lib/rubocop/cop/{style → layout}/empty_lines_around_module_body.rb

@@ -1,33 +1,47 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks if empty lines around the bodies of modules match
       # the configuration.
       #
-      # @example
-      #
-      #   EnforcedStyle: empty_lines
-      #
+      # @example EnforcedStyle: empty_lines
       #   # good
       #
       #   module Foo
       #
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #
       #   end
       #
-      #   EnforcedStyle: no_empty_lines
+      # @example EnforcedStyle: empty_lines_except_namespace
+      #   # good
+      #
+      #   module Foo
+      #     module Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
       #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   module Foo
+      #
+      #     def bar; end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: no_empty_lines (default)
       #   # good
       #
       #   module Foo
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #   end
       class EmptyLinesAroundModuleBody < Cop
@@ -39,6 +53,10 @@ module RuboCop
           _name, body = *node
           check(node, body)
         end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
       end
     end
   end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for Windows-style line endings in the source code.
+      class EndOfLine < Cop
+        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
+          last_line =
+            last_token ? last_token.line : processed_source.lines.length
+
+          processed_source.raw_source.each_line.with_index do |line, index|
+            break if index >= last_line
+            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, location: range, message: 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
+end

data/lib/rubocop/cop/{style → layout}/extra_spacing.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'set'
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks for extra/unnecessary whitespace.
       #
       # @example
@@ -24,21 +23,15 @@ module RuboCop
         include PrecedingFollowingAlignment
 
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
+                             'assignment.'.freeze
 
         def investigate(processed_source)
           return if processed_source.ast.nil?
 
           if force_equal_sign_alignment?
-            @asgn_tokens = processed_source.tokens.select { |t| equal_sign?(t) }
-            # we don't want to operate on equals signs which are part of an
-            #   optarg in a method definition
-            # e.g.: def method(optarg = default_val); end
-            @asgn_tokens = remove_optarg_equals(@asgn_tokens, processed_source)
-
-            # Only attempt to align the first = on each line
-            @asgn_tokens = Set.new(@asgn_tokens.uniq { |t| t.pos.line })
-            @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
+            @asgn_tokens = assignment_tokens
+            @asgn_lines  = @asgn_tokens.map(&:line)
             # Don't attempt to correct the same = more than once
             @corrected   = Set.new
           end
@@ -51,7 +44,7 @@ module RuboCop
         def autocorrect(range)
           lambda do |corrector|
             if range.source.end_with?('=')
-              align_equal_sign(range, corrector)
+              align_equal_signs(range, corrector)
             else
               corrector.remove(range)
             end
@@ -60,13 +53,24 @@ module RuboCop
 
         private
 
+        def assignment_tokens
+          tokens = processed_source.tokens.select(&:equal_sign?)
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq(&:line))
+        end
+
         def check_tokens(ast, t1, t2)
           return if t2.type == :tNL
 
           if force_equal_sign_alignment? &&
              @asgn_tokens.include?(t2) &&
-             (@asgn_lines.include?(t2.pos.line - 1) ||
-              @asgn_lines.include?(t2.pos.line + 1))
+             (@asgn_lines.include?(t2.line - 1) ||
+              @asgn_lines.include?(t2.line + 1))
             check_assignment(t2)
           else
             check_other(t1, t2, ast)
@@ -78,46 +82,51 @@ module RuboCop
           message = ''
           if should_aligned_with_preceding_line?(token)
             assignment_line = preceding_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'preceding')
+            message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           else
             assignment_line = following_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'following')
+            message = format(MSG_UNALIGNED_ASGN, location: 'following')
           end
           return if aligned_assignment?(token.pos, assignment_line)
-          add_offense(token.pos, token.pos, message)
+          add_offense(token.pos, location: token.pos, message: message)
         end
 
         def should_aligned_with_preceding_line?(token)
-          @asgn_lines.include?(token.pos.line - 1)
+          @asgn_lines.include?(token.line - 1)
         end
 
         def preceding_line(token)
-          processed_source.lines[token.pos.line - 2]
+          processed_source.lines[token.line - 2]
         end
 
         def following_line(token)
-          processed_source.lines[token.pos.line]
+          processed_source.lines[token.line]
         end
 
         def check_other(t1, t2, ast)
-          return if t1.pos.line != t2.pos.line
-          return if allow_for_alignment? && aligned_tok?(t2)
+          extra_space_range(t1, t2) do |range|
+            # Unary + doesn't appear as a token and needs special handling.
+            next if ignored_range?(ast, range.begin_pos)
+            next if unary_plus_non_offense?(range)
 
-          start_pos = t1.pos.end_pos
-          end_pos = t2.pos.begin_pos - 1
+            add_offense(range, location: range, message: MSG_UNNECESSARY)
+          end
+        end
+
+        def extra_space_range(t1, t2)
+          return if t1.line != t2.line
+
+          start_pos = t1.end_pos
+          end_pos = t2.begin_pos - 1
           return if end_pos <= start_pos
-          return if ignored_range?(ast, start_pos)
 
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            start_pos, end_pos)
-          # Unary + doesn't appear as a token and needs special handling.
-          return if unary_plus_non_offense?(range)
+          return if allow_for_alignment? && aligned_tok?(t2)
 
-          add_offense(range, range, MSG_UNNECESSARY)
+          yield range_between(start_pos, end_pos)
         end
 
         def aligned_tok?(token)
-          if token.type == :tCOMMENT
+          if token.comment?
             aligned_comments?(token)
           else
             aligned_with_something?(token.pos)
@@ -133,20 +142,22 @@ module RuboCop
         end
 
         # Returns an array of ranges that should not be reported. It's the
-        # extra spaces between the keys and values in a hash, since those are
-        # handled by the Style/AlignHash cop.
+        # extra spaces between the keys and values in a multiline hash,
+        # since those are handled by the Style/AlignHash cop.
         def ignored_ranges(ast)
           return [] unless ast
 
           @ignored_ranges ||= on_node(:pair, ast).map do |pair|
+            next if pair.parent.single_line?
+
             key, value = *pair
             key.source_range.end_pos...value.source_range.begin_pos
-          end
+          end.compact
         end
 
         def aligned_comments?(token)
           ix = processed_source.comments.index do |c|
-            c.loc.expression.begin_pos == token.pos.begin_pos
+            c.loc.expression.begin_pos == token.begin_pos
           end
           aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
         end
@@ -168,26 +179,25 @@ module RuboCop
           cop_config['ForceEqualSignAlignment']
         end
 
-        def equal_sign?(token)
-          token.type == :tEQL || token.type == :tOP_ASGN
-        end
-
-        def align_equal_sign(range, corrector)
+        def align_equal_signs(range, corrector)
           lines  = contiguous_assignment_lines(range)
-          tokens = @asgn_tokens.select { |t| lines.include?(t.pos.line) }
+          tokens = @asgn_tokens.select { |t| lines.include?(t.line) }
 
           columns  = tokens.map { |t| align_column(t) }
           align_to = columns.max
 
-          tokens.each do |token|
-            next unless @corrected.add?(token)
-            diff = align_to - token.pos.last_column
+          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
+        end
 
-            if diff > 0
-              corrector.insert_before(token.pos, ' ' * diff)
-            elsif diff < 0
-              corrector.remove_preceding(token.pos, -diff)
-            end
+        def align_equal_sign(corrector, token, align_to)
+          return unless @corrected.add?(token)
+
+          diff = align_to - token.pos.last_column
+
+          if diff > 0
+            corrector.insert_before(token.pos, ' ' * diff)
+          elsif diff < 0
+            corrector.remove_preceding(token.pos, -diff)
           end
         end
 
@@ -207,8 +217,8 @@ module RuboCop
         def align_column(asgn_token)
           # if we removed unneeded spaces from the beginning of this =,
           # what column would it end from?
-          line    = processed_source.lines[asgn_token.pos.line - 1]
-          leading = line[0...asgn_token.pos.column]
+          line    = processed_source.lines[asgn_token.line - 1]
+          leading = line[0...asgn_token.column]
           spaces  = leading.size - (leading =~ / *\Z/)
           asgn_token.pos.last_column - spaces + 1
         end
@@ -216,7 +226,7 @@ module RuboCop
         def remove_optarg_equals(asgn_tokens, processed_source)
           optargs    = processed_source.ast.each_node(:optarg)
           optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
-          asgn_tokens.reject { |t| optarg_eql.include?(t.pos.begin_pos) }
+          asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
         end
       end
     end

data/lib/rubocop/cop/{style → layout}/first_array_element_line_break.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks for a line break before the first element in a
       # multi-line array.
       #
@@ -30,6 +29,10 @@ module RuboCop
           check_children_line_break(node, node.children)
         end
 
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+
         private
 
         def assignment_on_same_line?(node)

data/lib/rubocop/cop/{style → layout}/first_hash_element_line_break.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks for a line break before the first element in a
       # multi-line hash.
       #
@@ -28,6 +27,10 @@ module RuboCop
           # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
           check_children_line_break(node, node.children) if node.loc.begin
         end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
       end
     end
   end

data/lib/rubocop/cop/{style → layout}/first_method_argument_line_break.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks for a line break before the first argument in a
       # multi-line method call.
       #
@@ -28,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:
           #
@@ -37,13 +36,17 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.loc.begin # no explicit {
+            if last_arg.hash_type? && !last_arg.braces?
               args = args.concat(args.pop.children)
             end
           end
 
           check_method_line_break(node, args)
         end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
       end
     end
   end

data/lib/rubocop/cop/{style → layout}/first_method_parameter_line_break.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks for a line break before the first parameter in a
       # multi-line method parameter definition.
       #
@@ -28,14 +27,18 @@ module RuboCop
       #       do_something
       #     end
       class FirstMethodParameterLineBreak < Cop
-        include OnMethodDef
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first parameter of a ' \
               'multi-line method parameter list.'.freeze
 
-        def on_method_def(node, _method_name, args, _body)
-          check_method_line_break(node, args.to_a)
+        def on_def(node)
+          check_method_line_break(node, node.arguments)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
         end
       end
     end