rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/{lint → layout}/end_alignment.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Lint
+    module Layout
       # This cop checks whether the end keywords are aligned properly.
       #
       # Three modes are supported through the `EnforcedStyleAlignWith`
@@ -17,42 +17,60 @@ module RuboCop
       # If it's set to `start_of_line`, the `end` shall be aligned with the
       # start of the line where the matching keyword appears.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
       #
       #   variable = if true
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: keyword (default)
-      #
       #   # good
       #
       #   variable = if true
       #              end
       #
-      # @example
+      #   variable =
+      #     if true
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: variable
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: variable
+      #   variable = if true
+      #       end
       #
       #   # good
       #
       #   variable = if true
       #   end
       #
-      # @example
+      #   variable =
+      #     if true
+      #     end
       #
-      #   # EnforcedStyleAlignWith: start_of_line
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   puts(if true
+      #        end)
       #
       #   # good
       #
+      #   variable = if true
+      #   end
+      #
       #   puts(if true
       #   end)
+      #
+      #   variable =
+      #     if true
+      #     end
       class EndAlignment < Cop
         include CheckAssignment
         include EndKeywordAlignment
+        include RangeHelp
 
         def on_class(node)
           check_other_alignment(node)
@@ -82,6 +100,12 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.align_end(processed_source,
+                                       node,
+                                       alignment_node(node))
+        end
+
         private
 
         def check_assignment(node, rhs)
@@ -89,7 +113,7 @@ module RuboCop
           # assignment, we let rhs be the receiver of those method calls before
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
-          return unless CONDITIONAL_NODES.include?(rhs.type)
+          return unless rhs.conditional?
           return if rhs.if_type? && rhs.ternary?
 
           check_asgn_alignment(node, rhs)
@@ -98,7 +122,7 @@ module RuboCop
         def check_asgn_alignment(outer_node, inner_node)
           align_with = {
             keyword: inner_node.loc.keyword,
-            start_of_line: start_line_range(outer_node),
+            start_of_line: start_line_range(inner_node),
             variable: asgn_variable_align_with(outer_node, inner_node)
           }
 
@@ -125,23 +149,31 @@ module RuboCop
           check_end_kw_alignment(node, align_with)
         end
 
-        def autocorrect(node)
-          align(node, alignment_node(node))
-        end
-
         def alignment_node(node)
           if style == :keyword
             node
           elsif style == :variable
-            return node.parent if node.case_type? && node.argument?
-            # Fall back to 'keyword' style if this node is not on the RHS
-            # of an assignment
-            node.ancestors.find(&:assignment?) || node
+            alignment_node_for_variable_style(node)
           else
             start_line_range(node)
           end
         end
 
+        def alignment_node_for_variable_style(node)
+          return node.parent if node.case_type? && node.argument?
+
+          assignment = node.ancestors.find(&:assignment_or_similar?)
+          if assignment && !line_break_before_keyword?(assignment.source_range,
+                                                       node)
+            assignment
+          else
+            # Fall back to 'keyword' style if this node is not on the RHS of an
+            # assignment, or if it is but there's a line break between LHS and
+            # RHS.
+            node
+          end
+        end
+
         def start_line_range(node)
           expr   = node.source_range
           buffer = expr.source_buffer

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

@@ -4,19 +4,52 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks for Windows-style line endings in the source code.
+      #
+      # @example EnforcedStyle: native (default)
+      #   # The `native` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on Windows, and LF is enforced on other platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on Windows.
+      #   puts 'Hello' # Return character is CR+LF on other than Windows.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on Windows.
+      #   puts 'Hello' # Return character is LF on other than Windows.
+      #
+      # @example EnforcedStyle: lf
+      #   # The `lf` style means that LF (Line Feed) is enforced on
+      #   # all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is LF on all platfoms.
+      #
+      # @example EnforcedStyle: crlf
+      #   # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on all platfoms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on all platfoms.
+      #
       class EndOfLine < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG_DETECTED = 'Carriage return character detected.'.freeze
-        MSG_MISSING = 'Carriage return character missing.'.freeze
+        MSG_DETECTED = 'Carriage return character detected.'
+        MSG_MISSING = 'Carriage return character missing.'
 
         def investigate(processed_source)
-          last_token = processed_source.tokens.last
-          last_line =
-            last_token ? last_token.pos.line : processed_source.lines.length
+          last_line = last_line(processed_source)
 
           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)
@@ -32,7 +65,7 @@ module RuboCop
 
         # 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$/
+          style == :crlf && index == last_line - 1 && !/\n$/.match?(line)
         end
 
         def offense_message(line)
@@ -42,10 +75,17 @@ module RuboCop
                               style
                             end
           case effective_style
-          when :lf then MSG_DETECTED if line =~ /\r$/
-          else MSG_MISSING if line !~ /\r$/
+          when :lf then MSG_DETECTED if line.end_with?("\r", "\r\n")
+          else MSG_MISSING unless line.end_with?("\r\n")
           end
         end
+
+        private
+
+        def last_line(processed_source)
+          last_token = processed_source.tokens.last
+          last_token ? last_token.line : processed_source.lines.length
+        end
       end
     end
   end

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

@@ -13,30 +13,38 @@ module RuboCop
       #   name      = "RuboCop"
       #   # Some comment and an empty line
       #
-      #   website  += "/bbatsov/rubocop" unless cond
+      #   website  += "/rubocop-hq/rubocop" unless cond
       #   puts        "rubocop"          if     debug
       #
       #   # bad for any configuration
       #   set_app("RuboCop")
-      #   website  = "https://github.com/bbatsov/rubocop"
+      #   website  = "https://github.com/rubocop-hq/rubocop"
+      #
+      #   # good only if AllowBeforeTrailingComments is true
+      #   object.method(arg)  # this is a comment
+      #
+      #   # good even if AllowBeforeTrailingComments is false or not set
+      #   object.method(arg) # this is a comment
+      #
+      #   # good with either AllowBeforeTrailingComments or AllowForAlignment
+      #   object.method(arg)         # this is a comment
+      #   another_object.method(arg) # this is another comment
+      #   some_object.method(arg)    # this is some comment
       class ExtraSpacing < Cop
         include PrecedingFollowingAlignment
+        include RangeHelp
 
-        MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
+        MSG_UNNECESSARY = 'Unnecessary spacing detected.'
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
+                             'assignment.'
 
         def investigate(processed_source)
-          return if processed_source.ast.nil?
+          return if processed_source.blank?
 
-          if force_equal_sign_alignment?
-            @asgn_tokens = assignment_tokens
-            @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
-            # Don't attempt to correct the same = more than once
-            @corrected   = Set.new
-          end
+          @corrected = Set.new if force_equal_sign_alignment?
 
-          processed_source.tokens.each_cons(2) do |t1, t2|
-            check_tokens(processed_source.ast, t1, t2)
+          processed_source.tokens.each_cons(2) do |token1, token2|
+            check_tokens(processed_source.ast, token1, token2)
           end
         end
 
@@ -52,80 +60,48 @@ module RuboCop
 
         private
 
-        def assignment_tokens
-          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
-          tokens = remove_optarg_equals(tokens, processed_source)
-
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq { |t| t.pos.line })
-        end
+        def check_tokens(ast, token1, token2)
+          return if token2.type == :tNL
 
-        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))
-            check_assignment(t2)
+          if force_equal_sign_alignment? && assignment_tokens.include?(token2)
+            check_assignment(token2)
           else
-            check_other(t1, t2, ast)
+            check_other(token1, token2, ast)
           end
         end
 
         def check_assignment(token)
-          assignment_line = ''
-          message = ''
-          if should_aligned_with_preceding_line?(token)
-            assignment_line = preceding_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'preceding')
-          else
-            assignment_line = following_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'following')
-          end
-          return if aligned_assignment?(token.pos, assignment_line)
-          add_offense(token.pos, location: token.pos, message: message)
-        end
+          return unless aligned_with_preceding_assignment(token) == :no
 
-        def should_aligned_with_preceding_line?(token)
-          @asgn_lines.include?(token.pos.line - 1)
-        end
-
-        def preceding_line(token)
-          processed_source.lines[token.pos.line - 2]
+          message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
+          add_offense(token.pos, location: token.pos, message: message)
         end
 
-        def following_line(token)
-          processed_source.lines[token.pos.line]
-        end
+        def check_other(token1, token2, ast)
+          return false if allow_for_trailing_comments? &&
+                          token2.text.start_with?('#')
 
-        def check_other(t1, t2, ast)
-          extra_space_range(t1, t2) do |range|
-            # Unary + doesn't appear as a token and needs special handling.
+          extra_space_range(token1, token2) do |range|
             next if ignored_range?(ast, range.begin_pos)
-            next if unary_plus_non_offense?(range)
 
             add_offense(range, location: range, message: MSG_UNNECESSARY)
           end
         end
 
-        def extra_space_range(t1, t2)
-          return if t1.pos.line != t2.pos.line
+        def extra_space_range(token1, token2)
+          return if token1.line != token2.line
 
-          start_pos = t1.pos.end_pos
-          end_pos = t2.pos.begin_pos - 1
+          start_pos = token1.end_pos
+          end_pos = token2.begin_pos - 1
           return if end_pos <= start_pos
 
-          return if allow_for_alignment? && aligned_tok?(t2)
+          return if allow_for_alignment? && aligned_tok?(token2)
 
           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)
@@ -136,13 +112,9 @@ module RuboCop
           ignored_ranges(ast).any? { |r| r.include?(start_pos) }
         end
 
-        def unary_plus_non_offense?(range)
-          range.resize(range.size + 1).source =~ /^ ?\+$/
-        end
-
         # Returns an array of ranges that should not be reported. It's the
         # extra spaces between the keys and values in a multiline hash,
-        # since those are handled by the Style/AlignHash cop.
+        # since those are handled by the Layout/HashAlignment cop.
         def ignored_ranges(ast)
           return [] unless ast
 
@@ -154,37 +126,33 @@ module RuboCop
           end.compact
         end
 
-        def aligned_comments?(token)
-          ix = processed_source.comments.index do |c|
-            c.loc.expression.begin_pos == token.pos.begin_pos
+        def aligned_comments?(comment_token)
+          ix = processed_source.comments.index do |comment|
+            comment.loc.expression.begin_pos == comment_token.begin_pos
           end
           aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
         end
 
-        def aligned_with_previous_comment?(ix)
-          ix > 0 && comment_column(ix - 1) == comment_column(ix)
+        def aligned_with_previous_comment?(index)
+          index.positive? && comment_column(index - 1) == comment_column(index)
         end
 
-        def aligned_with_next_comment?(ix)
-          ix < processed_source.comments.length - 1 &&
-            comment_column(ix + 1) == comment_column(ix)
+        def aligned_with_next_comment?(index)
+          index < processed_source.comments.length - 1 &&
+            comment_column(index + 1) == comment_column(index)
         end
 
-        def comment_column(ix)
-          processed_source.comments[ix].loc.column
+        def comment_column(index)
+          processed_source.comments[index].loc.column
         end
 
         def force_equal_sign_alignment?
           cop_config['ForceEqualSignAlignment']
         end
 
-        def equal_sign?(token)
-          token.type == :tEQL || token.type == :tOP_ASGN
-        end
-
         def align_equal_signs(range, corrector)
-          lines  = contiguous_assignment_lines(range)
-          tokens = @asgn_tokens.select { |t| lines.include?(t.pos.line) }
+          lines  = all_relevant_assignment_lines(range.line)
+          tokens = assignment_tokens.select { |t| lines.include?(t.line) }
 
           columns  = tokens.map { |t| align_column(t) }
           align_to = columns.max
@@ -197,39 +165,35 @@ module RuboCop
 
           diff = align_to - token.pos.last_column
 
-          if diff > 0
+          if diff.positive?
             corrector.insert_before(token.pos, ' ' * diff)
-          elsif diff < 0
+          elsif diff.negative?
             corrector.remove_preceding(token.pos, -diff)
           end
         end
 
-        def contiguous_assignment_lines(range)
-          result = [range.line]
-
-          range.line.downto(1) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
-          range.line.upto(processed_source.lines.size) do |lineno|
-            @asgn_lines.include?(lineno) ? result << lineno : break
-          end
+        def all_relevant_assignment_lines(line_number)
+          last_line_number = processed_source.lines.size
 
-          result.sort!
+          (
+            relevant_assignment_lines(line_number.downto(1)) +
+            relevant_assignment_lines(line_number.upto(last_line_number))
+          )
+            .uniq
+            .sort
         end
 
         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
 
-        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) }
+        def allow_for_trailing_comments?
+          cop_config['AllowBeforeTrailingComments']
         end
       end
     end