rubocop 0.35.1 → 0.36.0

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # If the `else` branch of a conditional consists solely of an `if` node,
+      # it can be combined with the `else` to become an `elsif`.
+      # This helps to keep the nesting level from getting too deep.
+      #
+      # @example
+      #   @good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   else
+      #     action_c
+      #   end
+      #
+      #   @bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     if condition_b
+      #       action_b
+      #     else
+      #       action_c
+      #     end
+      #   end
+      class IfInsideElse < Cop
+        include IfNode
+
+        MSG = 'Convert `if` nested inside `else` to `elsif`.'.freeze
+
+        def on_if(node)
+          _cond, _if_branch, else_branch = *node
+          return unless else_branch
+          return unless else_branch.if_type?
+          return if ternary_op?(node) || ternary_op?(else_branch)
+          return unless else_branch.loc.keyword.is?('if')
+          return if node.loc.keyword.is?('unless')
+
+          add_offense(else_branch, :keyword, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,7 +10,8 @@ module RuboCop
       class IfUnlessModifier < Cop
         include StatementModifier
 
-        ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn, :gvasgn, :ivasgn, :masgn]
+        ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn,
+                            :gvasgn, :ivasgn, :masgn].freeze
 
         def message(keyword)
           "Favor modifier `#{keyword}` usage when having a single-line body." \
@@ -50,7 +52,7 @@ module RuboCop
         end
 
         def method_uses_parens?(node, limit)
-          source = node.loc.expression.source_line[0...limit.loc.column]
+          source = node.source_range.source_line[0...limit.loc.column]
           source =~ /\s*\(\s*$/
         end
 
@@ -58,8 +60,7 @@ module RuboCop
           cond, body, _else = if_node_parts(node)
 
           oneline =
-            "#{body.loc.expression.source} #{node.loc.keyword.source} " +
-            cond.loc.expression.source
+            "#{body.source} #{node.loc.keyword.source} " + cond.source
           first_line_comment = processed_source.comments.find do |c|
             c.loc.line == node.loc.line
           end
@@ -68,7 +69,7 @@ module RuboCop
           end
           oneline = "(#{oneline})" if parenthesize?(node)
 
-          ->(corrector) { corrector.replace(node.loc.expression, oneline) }
+          ->(corrector) { corrector.replace(node.source_range, oneline) }
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,7 +8,7 @@ module RuboCop
       class IfWithSemicolon < Cop
         include OnNormalIfUnless
 
-        MSG = 'Do not use if x; Use the ternary operator instead.'
+        MSG = 'Do not use if x; Use the ternary operator instead.'.freeze
 
         def on_normal_if_unless(node)
           beginning = node.loc.begin

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

@@ -1,62 +1,113 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cops checks the indentation of the first element in an array
-      # literal where the opening bracket and the first element are on separate
-      # lines. The other elements' indentations are handled by the AlignArray
-      # cop.
+      # This cop checks the indentation of the first element in an array literal
+      # where the opening bracket and the first element are on separate lines.
+      # The other elements' indentations are handled by the AlignArray cop.
+      #
+      # By default, array literals that are arguments in a method call with
+      # parentheses, and where the opening square bracket of the array is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first element indented one step (two spaces) more than the
+      # position inside the opening parenthesis.
+      #
+      # Other array literals shall have their first element indented one step
+      # more than the start of the line where the opening square bracket is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_brackets'. Here are examples:
+      #
+      #     # special_inside_parentheses
+      #     array = [
+      #       :value
+      #     ]
+      #     but_in_a_method_call([
+      #                            :its_like_this
+      #                          ])
+      #     # consistent
+      #     array = [
+      #       :value
+      #     ]
+      #     and_in_a_method_call([
+      #       :no_difference
+      #     ])
+      #     # align_brackets
+      #     and_now_for_something = [
+      #                               :completely_different
+      #                             ]
       #
-      # Array literals shall have their first element indented one step (2
-      # spaces) more than the start of the line where the opening bracket is.
       class IndentArray < Cop
         include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+        include ArrayHashIndentation
 
         def on_array(node)
-          left_bracket = node.loc.begin
-          return if left_bracket.nil?
+          check(node, nil) if node.loc.begin
+        end
 
-          first_pair = node.children.first
-          check_first_pair(first_pair, left_bracket)
-          check_right_bracket(node, first_pair, left_bracket)
+        def on_send(node)
+          each_argument_node(node, :array) do |array_node, left_parenthesis|
+            check(array_node, left_parenthesis)
+          end
         end
 
-        def check_first_pair(first_pair, left_bracket)
-          return if first_pair.nil?
-          expr = first_pair.loc.expression
-          return if expr.line == left_bracket.line
+        private
 
-          base_column = left_bracket.source_line =~ /\S/
-          expected_column = base_column + configured_indentation_width
-          @column_delta = expected_column - expr.column
-          return if @column_delta == 0
+        def brace_alignment_style
+          :align_brackets
+        end
+
+        def check(array_node, left_parenthesis)
+          return if ignored_node?(array_node)
 
-          msg = format('Use %d spaces for indentation in an array, relative ' \
-                       'to the start of the line where the left bracket is.',
-                       configured_indentation_width)
-          add_offense(first_pair, :expression, msg)
+          left_bracket = array_node.loc.begin
+          first_elem = array_node.children.first
+          if first_elem
+            return if first_elem.source_range.line == left_bracket.line
+            check_first(first_elem, left_bracket, left_parenthesis, 0)
+          end
+
+          check_right_bracket(array_node.loc.end, left_bracket,
+                              left_parenthesis)
         end
 
-        def check_right_bracket(node, first_pair, left_bracket)
-          right_bracket = node.loc.end
-          column = right_bracket.column
-          return if right_bracket.source_line[0...column] =~ /\S/
+        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+          # if the right bracket is on the same line as the last value, accept
+          return if right_bracket.source_line[0...right_bracket.column] =~ /\S/
+
+          expected_column = base_column(left_bracket, left_parenthesis)
+          @column_delta = expected_column - right_bracket.column
+          return if @column_delta == 0
+
+          msg = if style == :align_brackets
+                  'Indent the right bracket the same as the left bracket.'
+                elsif style == :special_inside_parentheses && left_parenthesis
+                  'Indent the right bracket the same as the first position ' \
+                  'after the preceding left parenthesis.'
+                else
+                  'Indent the right bracket the same as the start of the line' \
+                  ' where the left bracket is.'
+                end
+          add_offense(right_bracket, right_bracket, msg)
+        end
 
-          if first_pair && first_pair.loc.expression.line == left_bracket.line
-            base_column = left_bracket.column
-            expected_indentation = 'the left bracket'
+        # Returns the description of what the correct indentation is based on.
+        def base_description(left_parenthesis)
+          if style == :align_brackets
+            'the position of the opening bracket'
+          elsif left_parenthesis && style == :special_inside_parentheses
+            'the first position after the preceding left parenthesis'
           else
-            base_column = left_bracket.source_line =~ /\S/
-            expected_indentation =
-              'the start of the line where the left bracket is'
+            'the start of the line where the left square bracket is'
           end
-          @column_delta = base_column - column
-          return if @column_delta == 0
+        end
 
-          add_offense(right_bracket, right_bracket,
-                      'Indent the right bracket the same as ' +
-                      expected_indentation + '.')
+        def message(base_description)
+          format('Use %d spaces for indentation in an array, relative to %s.',
+                 configured_indentation_width, base_description)
         end
       end
     end

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the indentation of the first line of the
+      # right-hand-side of a multi-line assignment.
+      #
+      # @example
+      #   # bad
+      #   value =
+      #   if foo
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   value =
+      #     if foo
+      #     'bar'
+      #   end
+      #
+      # The indentation of the remaining lines can be corrected with
+      # other cops such as `IndentationConsistency` and `EndAlignment`.
+      class IndentAssignment < Cop
+        include CheckAssignment
+        include AutocorrectAlignment
+
+        MSG = 'Indent the first line of the right-hand-side of a ' \
+              'multi-line assignment.'.freeze
+
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless node.loc.operator
+          return if node.loc.operator.line == rhs.loc.line
+
+          base = node.source_range.column
+          check_alignment([rhs], base + configured_indentation_width)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -41,43 +42,37 @@ module RuboCop
       class IndentHash < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
+        include ArrayHashIndentation
 
         def on_hash(node)
-          left_brace = node.loc.begin
-          check(node, left_brace, nil) if left_brace
+          check(node, nil) if node.loc.begin
         end
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
-          left_parenthesis = node.loc.begin
-          return unless left_parenthesis
-
-          args.each do |arg|
-            on_node(:hash, arg, :send) do |hash_node|
-              left_brace = hash_node.loc.begin
-              if left_brace && left_brace.line == left_parenthesis.line
-                check(hash_node, left_brace, left_parenthesis)
-                ignore_node(hash_node)
-              end
-            end
+          each_argument_node(node, :hash) do |hash_node, left_parenthesis|
+            check(hash_node, left_parenthesis)
           end
         end
 
         private
 
-        def check(hash_node, left_brace, left_parenthesis)
+        def brace_alignment_style
+          :align_braces
+        end
+
+        def check(hash_node, left_parenthesis)
           return if ignored_node?(hash_node)
 
+          left_brace = hash_node.loc.begin
           first_pair = hash_node.children.first
           if first_pair
-            left_brace = hash_node.loc.begin
-            return if first_pair.loc.expression.line == left_brace.line
+            return if first_pair.source_range.line == left_brace.line
 
             if separator_style?(first_pair)
               check_based_on_longest_key(hash_node.children, left_brace,
                                          left_parenthesis)
             else
-              check_first_pair(first_pair, left_brace, left_parenthesis, 0)
+              check_first(first_pair, left_brace, left_parenthesis, 0)
             end
           end
 
@@ -112,66 +107,10 @@ module RuboCop
 
         def check_based_on_longest_key(pairs, left_brace, left_parenthesis)
           key_lengths = pairs.map do |pair|
-            pair.children.first.loc.expression.length
-          end
-          check_first_pair(pairs.first, left_brace, left_parenthesis,
-                           key_lengths.max - key_lengths.first)
-        end
-
-        def check_first_pair(first_pair, left_brace, left_parenthesis, offset)
-          actual_column = first_pair.loc.expression.column
-          expected_column = base_column(left_brace, left_parenthesis) +
-                            configured_indentation_width + offset
-          @column_delta = expected_column - actual_column
-
-          if @column_delta == 0
-            # which column was actually used as 'base column' for indentation?
-            # (not the column which we think should be the 'base column',
-            # but the one which has actually been used for that purpose)
-            base_column = actual_column - configured_indentation_width - offset
-            styles = detected_styles(base_column, left_parenthesis, left_brace)
-            if styles.size > 1
-              ambiguous_style_detected(*styles)
-            else
-              correct_style_detected
-            end
-          else
-            incorrect_style_detected(actual_column, offset, first_pair,
-                                     left_parenthesis, left_brace)
-          end
-        end
-
-        def incorrect_style_detected(column, offset, first_pair,
-                                     left_parenthesis, left_brace)
-          add_offense(first_pair, :expression,
-                      message(base_description(left_parenthesis))) do
-            base_column = column - configured_indentation_width - offset
-            styles = detected_styles(base_column, left_parenthesis, left_brace)
-            ambiguous_style_detected(*styles)
-          end
-        end
-
-        def detected_styles(column, left_parenthesis, left_brace)
-          styles = []
-          if column == (left_brace.source_line =~ /\S/)
-            styles << :consistent
-            styles << :special_inside_parentheses unless left_parenthesis
-          end
-          if left_parenthesis && column == left_parenthesis.column + 1
-            styles << :special_inside_parentheses
-          end
-          styles << :align_braces if column == left_brace.column
-          styles
-        end
-
-        def base_column(left_brace, left_parenthesis)
-          if style == :align_braces
-            left_brace.column
-          elsif left_parenthesis && style == :special_inside_parentheses
-            left_parenthesis.column + 1
-          else
-            left_brace.source_line =~ /\S/
+            pair.children.first.source_range.length
           end
+          check_first(pairs.first, left_brace, left_parenthesis,
+                      key_lengths.max - key_lengths.first)
         end
 
         # Returns the description of what the correct indentation is based on.

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -18,7 +19,7 @@ module RuboCop
         include AccessModifierNode
         include ConfigurableEnforcedStyle
 
-        MSG = 'Inconsistent indentation detected.'
+        MSG = 'Inconsistent indentation detected.'.freeze
 
         def on_begin(node)
           check(node)