rubocop 0.46.0 → 0.47.0

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

@@ -44,7 +44,7 @@ module RuboCop
         def on_conditionals(node)
           condition_node, = *node
 
-          condition_node.each_node(:and, :or) do |logical_node|
+          condition_node.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
             process_logical_op(logical_node)
           end
         end

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

@@ -11,25 +11,24 @@ module RuboCop
         MSG = '%s curly braces around a hash parameter.'.freeze
 
         def on_send(node)
+          return if node.asgn_method_call?
+
           _receiver, method_name, *args = *node
 
-          # Discard attr writer methods.
-          return if node.asgn_method_call?
-          # Discard operator methods.
           return if operator?(method_name)
+          return if args.empty?
 
-          # We care only for the last argument.
-          arg = args.last
+          return unless args.last.hash_type? && !args.last.pairs.empty?
 
-          check(arg, args) if non_empty_hash?(arg)
+          check(args.last, args)
         end
 
         private
 
         def check(arg, args)
-          if style == :braces && !braces?(arg)
+          if style == :braces && !arg.braces?
             add_offense(arg.parent, arg.source_range, format(MSG, 'Missing'))
-          elsif style == :no_braces && braces?(arg)
+          elsif style == :no_braces && arg.braces?
             add_offense(arg.parent, arg.source_range,
                         format(MSG, 'Redundant'))
           elsif style == :context_dependent
@@ -38,8 +37,8 @@ module RuboCop
         end
 
         def check_context_dependent(arg, args)
-          braces_around_second_from_end = args.length > 1 && args[-2].hash_type?
-          if braces?(arg)
+          braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
+          if arg.braces?
             unless braces_around_second_from_end
               add_offense(arg.parent, arg.source_range,
                           format(MSG, 'Redundant'))
@@ -57,7 +56,7 @@ module RuboCop
           _receiver, _method_name, *args = *send_node
           node = args.last
           lambda do |corrector|
-            if braces?(node)
+            if node.braces?
               remove_braces_with_whitespace(corrector, node)
             else
               add_braces(corrector, node)
@@ -100,10 +99,6 @@ module RuboCop
           corrector.insert_after(node.source_range, '}')
         end
 
-        def non_empty_hash?(arg)
-          arg && arg.hash_type? && !arg.children.empty?
-        end
-
         def braces?(arg)
           arg.loc.begin
         end

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

@@ -11,39 +11,41 @@ module RuboCop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
 
-        def on_case(case_node)
-          _condition, *whens, _else = *case_node
-
-          base = style
-          indent = cop_config['IndentOneStep']
-          base_column = base_column(case_node, base)
+        MSG = 'Indent `when` %s `%s`.'.freeze
 
-          whens.each do |when_node|
-            check_when(when_node, case_node, base, indent, base_column)
+        def on_case(case_node)
+          case_node.each_when do |when_node|
+            check_when(when_node)
           end
         end
 
         private
 
-        def check_when(when_node, case_node, base, indent, base_column)
-          pos = when_node.loc.keyword
-          expected_column = base_column +
-                            (indent ? configured_indentation_width : 0)
-          if pos.column == expected_column
+        def check_when(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, style)
+
+          if when_column == base_column + indentation_width
             correct_style_detected
           else
-            incorrect_style(when_node, case_node, base, pos, indent)
+            incorrect_style(when_node)
           end
         end
 
-        def incorrect_style(when_node, case_node, base, pos, indent)
-          msg = 'Indent `when` ' + if indent
-                                     "one step more than `#{base}`."
-                                   else
-                                     "as deep as `#{base}`."
-                                   end
-          add_offense(when_node, pos, msg) do
-            if pos.column == base_column(case_node, alternative_style)
+        def indent_one_step?
+          cop_config['IndentOneStep']
+        end
+
+        def indentation_width
+          indent_one_step? ? configured_indentation_width : 0
+        end
+
+        def incorrect_style(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, alternative_style)
+
+          add_offense(when_node, :keyword, message(style)) do
+            if when_column == base_column
               opposite_style_detected
             else
               unrecognized_style_detected
@@ -51,8 +53,10 @@ module RuboCop
           end
         end
 
-        def parameter_name
-          'IndentWhenRelativeTo'
+        def message(base)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+
+          format(MSG, depth, base)
         end
 
         def base_column(case_node, base)
@@ -64,9 +68,12 @@ module RuboCop
 
         def autocorrect(node)
           whitespace = whitespace_range(node)
+
           return false unless whitespace.source.strip.empty?
 
-          ->(corrector) { corrector.replace(whitespace, replacement(node)) }
+          lambda do |corrector|
+            corrector.replace(whitespace, replacement(node))
+          end
         end
 
         def whitespace_range(node)
@@ -78,9 +85,11 @@ module RuboCop
 
         def replacement(node)
           case_node = node.each_ancestor(:case).first
-          base_type = cop_config[parameter_name] == 'end' ? :end : :case
+          base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
+
           column = base_column(case_node, base_type)
-          column += configured_indentation_width if cop_config['IndentOneStep']
+          column += indentation_width
+
           ' ' * column
         end
       end

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

@@ -8,7 +8,7 @@ module RuboCop
       module ConditionalAssignmentHelper
         EQUAL = '='.freeze
         END_ALIGNMENT = 'Lint/EndAlignment'.freeze
-        ALIGN_WITH = 'AlignWith'.freeze
+        ALIGN_WITH = 'EnforcedStyleAlignWith'.freeze
         KEYWORD = 'keyword'.freeze
 
         # `elsif` branches show up in the `node` as an `else`. We need
@@ -92,6 +92,12 @@ module RuboCop
           method_name.to_s.end_with?(EQUAL) &&
             ![:!=, :==, :===, :>=, :<=].include?(method_name)
         end
+
+        def assignment_rhs_exist?(node)
+          parent = node.parent
+          return true unless parent
+          !(parent.mlhs_type? || parent.resbody_type?)
+        end
       end
 
       # Check for `if` and `case` statements where each branch is used for
@@ -190,7 +196,6 @@ module RuboCop
       #     bar = 2
       #   end
       class ConditionalAssignment < Cop
-        include IfNode
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
         include IgnoredNode
@@ -201,10 +206,8 @@ module RuboCop
           'Assign variables inside of conditionals'.freeze
         VARIABLE_ASSIGNMENT_TYPES =
           [:casgn, :cvasgn, :gvasgn, :ivasgn, :lvasgn].freeze
-        ASSIGNMENT_TYPES =
-          VARIABLE_ASSIGNMENT_TYPES + [:and_asgn, :or_asgn, :op_asgn].freeze
-        IF = 'if'.freeze
-        UNLESS = 'unless'.freeze
+        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
+                           [:and_asgn, :or_asgn, :op_asgn, :masgn].freeze
         LINE_LENGTH = 'Metrics/LineLength'.freeze
         INDENTATION_WIDTH = 'Style/IndentationWidth'.freeze
         ENABLED = 'Enabled'.freeze
@@ -218,6 +221,7 @@ module RuboCop
           define_method "on_#{type}" do |node|
             return if part_of_ignored_node?(node)
             return unless style == :assign_inside_condition
+            return unless assignment_rhs_exist?(node)
 
             check_assignment_to_condition(node)
           end
@@ -226,53 +230,56 @@ module RuboCop
         def on_send(node)
           return unless assignment_type?(node)
           return unless style == :assign_inside_condition
+          return unless assignment_rhs_exist?(node)
 
           check_assignment_to_condition(node)
         end
 
-        def check_assignment_to_condition(node)
-          ignore_node(node)
-
-          assignment = assignment_node(node)
-          return unless condition?(assignment)
-
-          _condition, *branches, else_branch = *assignment
-          return unless else_branch # empty else
-          return if single_line_conditions_only? &&
-                    [*branches, else_branch].any?(&:begin_type?)
-
-          add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
-        end
-
         def on_if(node)
           return unless style == :assign_to_condition
-          return if elsif?(node)
-
-          if ternary?(node) || node.loc.keyword.is?('if')
-            _condition, if_branch, else_branch = *node
-          else
-            _condition, else_branch, if_branch = *node
-          end
+          return if node.elsif?
 
+          else_branch = node.else_branch
           elsif_branches, else_branch = expand_elses(else_branch)
-          return unless else_branch # empty else
 
-          branches = [if_branch, *elsif_branches, else_branch]
+          return unless else_branch
+
+          branches = [node.if_branch, *elsif_branches, else_branch]
 
           check_node(node, branches)
         end
 
         def on_case(node)
           return unless style == :assign_to_condition
-          _condition, *when_branches, else_branch = *node
-          return unless else_branch # empty else
+          return unless node.else_branch
 
-          when_branches = expand_when_branches(when_branches)
-          branches = [*when_branches, else_branch]
+          when_branches = expand_when_branches(node.when_branches)
+          branches = [*when_branches, node.else_branch]
 
           check_node(node, branches)
         end
 
+        private
+
+        def check_assignment_to_condition(node)
+          ignore_node(node)
+
+          assignment = assignment_node(node)
+          return unless condition?(assignment)
+          return if allowed_ternary?(assignment)
+
+          _condition, *branches, else_branch = *assignment
+          return unless else_branch # empty else
+          return if single_line_conditions_only? &&
+                    [*branches, else_branch].any?(&:begin_type?)
+
+          add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
+        end
+
+        def allowed_ternary?(assignment)
+          assignment.if_type? && assignment.ternary? && !include_ternary?
+        end
+
         def autocorrect(node)
           if assignment_type?(node)
             move_assignment_inside_condition(node)
@@ -281,8 +288,6 @@ module RuboCop
           end
         end
 
-        private
-
         def assignment_node(node)
           *_variable, assignment = *node
 
@@ -298,20 +303,21 @@ module RuboCop
         end
 
         def move_assignment_outside_condition(node)
-          if ternary?(node)
+          if node.case_type?
+            CaseCorrector.correct(self, node)
+          elsif node.ternary?
             TernaryCorrector.correct(node)
-          elsif node.loc.keyword.is?(IF)
+          elsif node.if?
             IfCorrector.correct(self, node)
-          elsif node.loc.keyword.is?(UNLESS)
+          elsif node.unless?
             UnlessCorrector.correct(self, node)
-          else
-            CaseCorrector.correct(self, node)
           end
         end
 
         def move_assignment_inside_condition(node)
           *_assignment, condition = *node
-          if ternary?(condition) || ternary?(condition.children[0])
+
+          if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(node)
           elsif condition.case_type?
             CaseCorrector.move_assignment_inside_condition(node)
@@ -320,6 +326,10 @@ module RuboCop
           end
         end
 
+        def ternary_condition?(node)
+          [node, node.children.first].any? { |n| n.if_type? && n.ternary? }
+        end
+
         def lhs_all_match?(branches)
           first_lhs = lhs(branches.first)
           branches.all? { |branch| lhs(branch) == first_lhs }
@@ -327,8 +337,8 @@ module RuboCop
 
         def assignment_types_match?(*nodes)
           return unless assignment_type?(nodes.first)
-          first_type = nodes.first.type
-          nodes.all? { |node| node.type == first_type }
+
+          nodes.map(&:type).uniq.one?
         end
 
         # The shovel operator `<<` does not have its own type. It is a `send`
@@ -337,15 +347,15 @@ module RuboCop
           return true if ASSIGNMENT_TYPES.include?(branch.type)
 
           if branch.send_type?
-            _receiver, method, = *branch
-            return true if METHODS.include?(method)
-            return true if method.to_s.end_with?(EQUAL)
+            return true if METHODS.include?(branch.method_name) ||
+                           branch.method_name.to_s.end_with?(EQUAL)
           end
 
           false
         end
 
         def check_node(node, branches)
+          return if allowed_ternary?(node)
           return unless allowed_statements?(branches)
           return if single_line_conditions_only? && branches.any?(&:begin_type?)
           return if correction_exceeds_line_limit?(node, branches)
@@ -400,7 +410,10 @@ module RuboCop
         end
 
         def longest_rhs(branches)
-          branches.map { |branch| branch.children.last.source.length }.max
+          line_lengths = branches.flat_map do |branch|
+            branch.children.last.source.split("\n").map(&:length)
+          end
+          line_lengths.max
         end
 
         def line_length_cop_enabled?
@@ -418,6 +431,10 @@ module RuboCop
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end
+
+        def include_ternary?
+          cop_config['IncludeTernaryExpressions']
+        end
       end
 
       # Helper module to provide common methods to ConditionalAssignment

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

@@ -40,11 +40,14 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            method, args, _body = *node
+            method, args, body = *node
             corrector.replace(method.loc.selector, 'each_with_object')
             first_arg, second_arg = *args
             corrector.replace(first_arg.loc.expression, second_arg.source)
             corrector.replace(second_arg.loc.expression, first_arg.source)
+
+            return_value = return_value(body)
+            corrector.remove(return_value.loc.expression)
           end
         end
 

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

@@ -11,34 +11,31 @@ module RuboCop
         include EndKeywordAlignment
         include AutocorrectAlignment
         include CheckAssignment
-        include IfNode
 
         MSG = 'Align `%s` with `%s`.'.freeze
 
         def on_if(node, base = nil)
           return if ignored_node?(node)
-          return unless if_else?(node)
+          return unless node.else? && begins_its_line?(node.loc.else)
 
-          else_range = node.loc.else
-          return unless begins_its_line?(else_range)
-
-          check_alignment(base_range(node, base), else_range)
+          check_alignment(base_range(node, base), node.loc.else)
 
-          _, _, else_body = *node
+          else_branch = node.else_branch
 
-          return unless else_body && elsif?(else_body)
+          return unless else_branch && else_branch.if_type? &&
+                        else_branch.elsif?
 
           # If the `else` part is actually an `elsif`, we check the `elsif`
           # node in case it contains an `else` within, because that `else`
           # should have the same alignment (base).
-          on_if(else_body, base)
+          on_if(else_branch, base)
           # The `elsif` node will get an `on_if` call from the framework later,
           # but we're done here, so we set it to ignored.
-          ignore_node(else_body)
+          ignore_node(else_branch)
         end
 
         def on_rescue(node)
-          return unless if_else?(node)
+          return unless node.loc.respond_to?(:else) && node.loc.else
 
           parent = node.parent
           parent = parent.parent if parent.ensure_type?
@@ -51,9 +48,9 @@ module RuboCop
         end
 
         def on_case(node)
-          _cond, *whens, _else = *node
-          return unless if_else?(node)
-          check_alignment(whens.last.loc.keyword, node.loc.else)
+          return unless node.else?
+
+          check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
         end
 
         private
@@ -62,11 +59,8 @@ module RuboCop
           if base
             base.source_range
           else
-            base = node
-            until %w(if unless).include?(base.loc.keyword.source)
-              base = base.parent
-            end
-            base.loc.keyword
+            lineage = [node, *node.each_ancestor(:if)]
+            lineage.find { |parent| parent.if? || parent.unless? }.loc.keyword
           end
         end
 
@@ -87,7 +81,7 @@ module RuboCop
           return unless rhs
 
           end_config = config.for_cop('Lint/EndAlignment')
-          style = end_config['AlignWith'] || 'keyword'
+          style = end_config['EnforcedStyleAlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           return unless rhs.if_type?