rubocop 0.52.1 → 0.53.0

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

@@ -36,6 +36,26 @@ module RuboCop
       #
       #   end
       #
+      # @example Enforcedstyle: beginning_only
+      #   # good
+      #
+      #   class Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #   end
+      #
+      # @example Enforcedstyle: ending_only
+      #   # good
+      #
+      #   class Foo
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
+      #
       # @example EnforcedStyle: no_empty_lines (default)
       #   # good
       #

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`
@@ -28,6 +28,10 @@ module RuboCop
       #   variable = if true
       #              end
       #
+      #   variable =
+      #     if true
+      #     end
+      #
       # @example EnforcedStyleAlignWith: variable
       #   # bad
       #
@@ -39,19 +43,34 @@ module RuboCop
       #   variable = if true
       #   end
       #
+      #   variable =
+      #     if true
+      #     end
+      #
       # @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)
@@ -103,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)
           }
 
@@ -134,15 +153,27 @@ module RuboCop
           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?)
+          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

@@ -6,6 +6,7 @@ module RuboCop
       # This cop checks for Windows-style line endings in the source code.
       class EndOfLine < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG_DETECTED = 'Carriage return character detected.'.freeze
         MSG_MISSING = 'Carriage return character missing.'.freeze

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

@@ -21,13 +21,14 @@ module RuboCop
       #   website  = "https://github.com/bbatsov/rubocop"
       class ExtraSpacing < Cop
         include PrecedingFollowingAlignment
+        include RangeHelp
 
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
                              'assignment.'.freeze
 
         def investigate(processed_source)
-          return if processed_source.ast.nil?
+          return if processed_source.blank?
 
           if force_equal_sign_alignment?
             @asgn_tokens = assignment_tokens
@@ -36,8 +37,8 @@ module RuboCop
             @corrected   = Set.new
           end
 
-          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
 
@@ -64,16 +65,16 @@ module RuboCop
           Set.new(tokens.uniq(&:line))
         end
 
-        def check_tokens(ast, t1, t2)
-          return if t2.type == :tNL
+        def check_tokens(ast, token1, token2)
+          return if token2.type == :tNL
 
           if force_equal_sign_alignment? &&
-             @asgn_tokens.include?(t2) &&
-             (@asgn_lines.include?(t2.line - 1) ||
-              @asgn_lines.include?(t2.line + 1))
-            check_assignment(t2)
+             @asgn_tokens.include?(token2) &&
+             (@asgn_lines.include?(token2.line - 1) ||
+              @asgn_lines.include?(token2.line + 1))
+            check_assignment(token2)
           else
-            check_other(t1, t2, ast)
+            check_other(token1, token2, ast)
           end
         end
 
@@ -81,10 +82,10 @@ module RuboCop
           assignment_line = ''
           message = ''
           if should_aligned_with_preceding_line?(token)
-            assignment_line = preceding_line(token)
+            assignment_line = processed_source.preceding_line(token)
             message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           else
-            assignment_line = following_line(token)
+            assignment_line = processed_source.following_line(token)
             message = format(MSG_UNALIGNED_ASGN, location: 'following')
           end
           return if aligned_assignment?(token.pos, assignment_line)
@@ -95,16 +96,8 @@ module RuboCop
           @asgn_lines.include?(token.line - 1)
         end
 
-        def preceding_line(token)
-          processed_source.lines[token.line - 2]
-        end
-
-        def following_line(token)
-          processed_source.lines[token.line]
-        end
-
-        def check_other(t1, t2, ast)
-          extra_space_range(t1, t2) do |range|
+        def check_other(token1, token2, ast)
+          extra_space_range(token1, token2) 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)
@@ -113,14 +106,14 @@ module RuboCop
           end
         end
 
-        def extra_space_range(t1, t2)
-          return if t1.line != t2.line
+        def extra_space_range(token1, token2)
+          return if token1.line != token2.line
 
-          start_pos = t1.end_pos
-          end_pos = t2.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
@@ -155,24 +148,24 @@ module RuboCop
           end.compact
         end
 
-        def aligned_comments?(token)
-          ix = processed_source.comments.index do |c|
-            c.loc.expression.begin_pos == token.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 > 0 && 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?

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

@@ -21,6 +21,7 @@ module RuboCop
       class FirstParameterIndentation < Cop
         include Alignment
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG = 'Indent the first parameter one step more than %<base>s.'.freeze
 

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

@@ -12,26 +12,62 @@ module RuboCop
       #       this cop does not add any offenses for long here documents to
       #       avoid `Metrics/LineLength`'s offenses.
       #
-      # @example
-      #
+      # @example EnforcedStyle: auto_detection (default)
       #   # bad
       #   <<-RUBY
       #   something
       #   RUBY
       #
       #   # good
+      #   # When using Ruby 2.3 or higher.
+      #   <<~RUBY
+      #     something
+      #   RUBY
+      #
+      #   # good
+      #   # When using Ruby 2.2 or lower and enabled Rails department.
+      #   # The following is possible to enable Rails department by
+      #   # adding for example:
+      #   #
+      #   # Rails:
+      #   #   Enabled: true
+      #   #
+      #   <<-RUBY.strip_heredoc
+      #     something
+      #   RUBY
+      #
+      # @example EnforcedStyle: squiggly
+      #   # good
       #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
       #   # following code.
       #   <<~RUBY
       #     something
       #   RUBY
       #
+      # @example EnforcedStyle: active_support
       #   # good
       #   # When EnforcedStyle is active_support, bad code is auto-corrected to
       #   # the following code.
       #   <<-RUBY.strip_heredoc
       #     something
       #   RUBY
+      #
+      # @example EnforcedStyle: powerpack
+      #   # good
+      #   # When EnforcedStyle is powerpack, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-RUBY.strip_indent
+      #     something
+      #   RUBY
+      #
+      # @example EnforcedStyle: unindent
+      #   # good
+      #   # When EnforcedStyle is unindent, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-RUBY.unindent
+      #     something
+      #   RUBY
+      #
       class IndentHeredoc < Cop
         include Heredoc
         include ConfigurableEnforcedStyle

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

@@ -5,14 +5,118 @@ module RuboCop
     module Layout
       # This cops checks for inconsistent indentation.
       #
-      # @example
+      # The difference between `rails` and `normal` is that the `rails` style
+      # prescribes that in classes and modules the `protected` and `private`
+      # modifier keywords shall be indented the same as public methods and that
+      # protected and private members shall be indented one step more than the
+      # modifiers. Other than that, both styles mean that entities on the same
+      # logical depth shall have the same indentation.
       #
+      # @example EnforcedStyle: normal (default)
+      #   # bad
       #   class A
       #     def test
       #       puts 'hello'
       #        puts 'world'
       #     end
       #   end
+      #
+      #   # bad
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #       def foo
+      #       end
+      #
+      #     private
+      #
+      #       def bar
+      #       end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #     def foo
+      #     end
+      #
+      #     private
+      #
+      #     def bar
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: rails
+      #   # bad
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #        puts 'world'
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #     def foo
+      #     end
+      #
+      #     private
+      #
+      #     def bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #   end
+      #
+      #   # good
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #       puts 'world'
+      #     end
+      #
+      #     protected
+      #
+      #       def foo
+      #       end
+      #
+      #     private
+      #
+      #       def bar
+      #       end
+      #   end
       class IndentationConsistency < Cop
         include Alignment
         include ConfigurableEnforcedStyle