rubocop 0.46.0 → 0.47.0

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

@@ -36,7 +36,6 @@ module RuboCop
       #   raise 'exception' if something
       #   ok
       class GuardClause < Cop
-        include IfNode
         include MinBodyLength
         include OnMethodDef
 
@@ -48,7 +47,7 @@ module RuboCop
 
           if body.if_type?
             check_ending_if(body)
-          elsif body.begin_type?
+          elsif body.begin_type? && body.children.last.if_type?
             check_ending_if(body.children.last)
           end
         end
@@ -56,39 +55,34 @@ module RuboCop
         def on_if(node)
           return if accepted_form?(node) || !contains_guard_clause?(node)
 
-          add_offense(node, :keyword, MSG)
+          add_offense(node, :keyword)
         end
 
         private
 
         def check_ending_if(node)
-          return if !node.if_type? ||
-                    accepted_form?(node, true) ||
-                    !min_body_length?(node)
+          return if accepted_form?(node, true) || !min_body_length?(node)
 
-          add_offense(node, :keyword, MSG)
+          add_offense(node, :keyword)
         end
 
         def accepted_form?(node, ending = false)
-          condition, = *node
-
-          ignored_node?(node, ending) || condition.multiline?
+          accepted_if?(node, ending) || node.condition.multiline?
         end
 
-        def ignored_node?(node, ending)
-          return true if modifier_if?(node) || ternary?(node)
+        def accepted_if?(node, ending)
+          return true if node.modifier_form? || node.ternary?
 
           if ending
-            if_else?(node)
+            node.else?
           else
-            !if_else?(node) || elsif?(node)
+            !node.else? || node.elsif?
           end
         end
 
         def contains_guard_clause?(node)
-          _, body, else_body = *node
-
-          guard_clause?(body) || guard_clause?(else_body)
+          node.if_branch && node.if_branch.guard_clause? ||
+            node.else_branch && node.else_branch.guard_clause?
         end
       end
     end

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

@@ -69,43 +69,31 @@ module RuboCop
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
 
-        def initialize(*)
-          @force_hash_rockets = false
-          super
-        end
-
         def on_hash(node)
-          if cop_config['UseHashRocketsWithSymbolValues']
-            pairs = *node
-            @force_hash_rockets = pairs.any? { |p| symbol_value?(p) }
-          end
+          return if node.pairs.empty?
+
+          @force_hash_rockets = force_hash_rockets?(node.pairs)
 
           if style == :hash_rockets || @force_hash_rockets
-            hash_rockets_check(node)
+            hash_rockets_check(node.pairs)
           elsif style == :ruby19_no_mixed_keys
-            ruby19_no_mixed_keys_check(node)
+            ruby19_no_mixed_keys_check(node.pairs)
           elsif style == :no_mixed_keys
-            no_mixed_keys_check(node)
+            no_mixed_keys_check(node.pairs)
           else
-            ruby19_check(node)
+            ruby19_check(node.pairs)
           end
         end
 
-        def ruby19_check(node)
-          pairs = *node
-
+        def ruby19_check(pairs)
           check(pairs, '=>', MSG_19) if sym_indices?(pairs)
         end
 
-        def hash_rockets_check(node)
-          pairs = *node
-
+        def hash_rockets_check(pairs)
           check(pairs, ':', MSG_HASH_ROCKETS)
         end
 
-        def ruby19_no_mixed_keys_check(node)
-          pairs = *node
-
+        def ruby19_no_mixed_keys_check(pairs)
           if @force_hash_rockets
             check(pairs, ':', MSG_HASH_ROCKETS)
           elsif sym_indices?(pairs)
@@ -115,14 +103,11 @@ module RuboCop
           end
         end
 
-        def no_mixed_keys_check(node)
-          pairs = *node
-
+        def no_mixed_keys_check(pairs)
           if !sym_indices?(pairs)
             check(pairs, ':', MSG_NO_MIXED_KEYS)
           else
-            delim = pairs.first.loc.operator.source == ':' ? '=>' : ':'
-            check(pairs, delim, MSG_NO_MIXED_KEYS)
+            check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
           end
         end
 
@@ -149,22 +134,14 @@ module RuboCop
 
         private
 
-        def symbol_value?(pair)
-          _key, value = *pair
-
-          value.sym_type?
-        end
-
         def sym_indices?(pairs)
           pairs.all? { |p| word_symbol_pair?(p) }
         end
 
         def word_symbol_pair?(pair)
-          key, _value = *pair
+          return false unless pair.key.sym_type?
 
-          return false unless key.sym_type?
-
-          acceptable_19_syntax_symbol?(key.source)
+          acceptable_19_syntax_symbol?(pair.key.source)
         end
 
         def acceptable_19_syntax_symbol?(sym_name)
@@ -186,7 +163,7 @@ module RuboCop
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
-            if pair.loc.operator && pair.loc.operator.is?(delim)
+            if pair.delimiter == delim
               add_offense(pair,
                           pair.source_range.begin.join(pair.loc.operator),
                           msg) do
@@ -212,20 +189,25 @@ module RuboCop
           key = node.children.first.source_range
           op = node.loc.operator
 
-          corrector.insert_after(key, ' => ')
+          corrector.insert_after(key, node.inverse_delimiter(true))
           corrector.insert_before(key, ':')
           corrector.remove(range_with_surrounding_space(op))
         end
 
         def autocorrect_no_mixed_keys(corrector, node)
-          op = node.loc.operator
-
-          if op.is?(':')
+          if node.colon?
             autocorrect_hash_rockets(corrector, node)
           else
             autocorrect_ruby19(corrector, node)
           end
         end
+
+        def force_hash_rockets?(pairs)
+          @force_hash_rockets ||= begin
+            cop_config['UseHashRocketsWithSymbolValues'] &&
+              pairs.map(&:value).any?(&:sym_type?)
+          end
+        end
       end
     end
   end

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical lines at the end of each branch of a
-      # conditional statement.
+      # This cop checks for identical lines at the beginning or end of
+      # each branch of a conditional statement.
       #
       # @example
       #   @bad
@@ -23,40 +23,58 @@ module RuboCop
       #     do_y
       #   end
       #   do_z
+      #
+      #   @bad
+      #   if condition
+      #     do_z
+      #     do_x
+      #   else
+      #     do_z
+      #     do_y
+      #   end
+      #
+      #   @good
+      #   do_z
+      #   if condition
+      #     do_x
+      #   else
+      #     do_y
+      #   end
       class IdenticalConditionalBranches < Cop
-        include IfNode
-
         MSG = 'Move `%s` out of the conditional.'.freeze
 
         def on_if(node)
-          return if elsif?(node)
-          _condition, if_branch, else_branch = *node
-          branches = expand_elses(else_branch).unshift(if_branch)
+          return if node.elsif?
+
+          branches = expand_elses(node.else_branch).unshift(node.if_branch)
 
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else`, or a branch that contains only comments.
           return if branches.any?(&:nil?)
 
-          check_node(branches)
+          check_branches(branches)
         end
 
         def on_case(node)
-          return unless node.loc.else
-          _condition, *when_branches, else_branch = *node
-          return unless else_branch # empty else
-          when_branches = expand_when_branches(when_branches)
+          return unless node.else? && node.else_branch
 
-          check_node(when_branches.push(else_branch))
+          check_branches(node.when_branches.map(&:body).push(node.else_branch))
         end
 
         private
 
-        def check_node(branches)
-          branches = branches.map { |branch| tail(branch) }
+        def check_branches(branches)
+          tails = branches.compact.map { |branch| tail(branch) }
+          check_expressions(tails)
+          heads = branches.compact.map { |branch| head(branch) }
+          check_expressions(heads)
+        end
+
+        def check_expressions(expressions)
+          return unless expressions.size > 1 && expressions.uniq.one?
 
-          return unless branches.all? { |branch| branch == branches[0] }
-          branches.each do |branch|
-            add_offense(branch, :expression, format(MSG, branch.source))
+          expressions.each do |expression|
+            add_offense(expression, :expression, format(MSG, expression.source))
           end
         end
 
@@ -73,18 +91,12 @@ module RuboCop
           end
         end
 
-        # `when` nodes contain the entire branch including the condition.
-        # We only need the contents of the branch, not the condition.
-        def expand_when_branches(when_branches)
-          when_branches.map { |branch| branch.children[1] }
+        def tail(node)
+          node.begin_type? ? node.children.last : node
         end
 
-        def tail(node)
-          if node && node.begin_type?
-            node.children.last
-          else
-            node
-          end
+        def head(node)
+          node.begin_type? ? node.children.first : node
         end
       end
     end

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

@@ -28,19 +28,16 @@ module RuboCop
       #     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?(node) || ternary?(else_branch)
-          return unless else_branch.loc.keyword.is?('if')
-          return if node.loc.keyword.is?('unless')
+          return if node.ternary? || node.unless?
+
+          else_branch = node.else_branch
+
+          return unless else_branch && else_branch.if_type? && else_branch.if?
 
-          add_offense(else_branch, :keyword, MSG)
+          add_offense(else_branch, :keyword)
         end
       end
     end

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

@@ -7,37 +7,36 @@ module RuboCop
       # if written as a modifier if/unless.
       # The maximum line length is configurable.
       class IfUnlessModifier < Cop
-        include IfNode
         include StatementModifier
 
+        MSG = 'Favor modifier `%s` usage when having a single-line body. ' \
+              'Another good alternative is the usage of control flow ' \
+              '`&&`/`||`.'.freeze
+
         ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn,
                             :gvasgn, :ivasgn, :masgn].freeze
 
         def on_if(node)
           return unless eligible_node?(node)
 
-          add_offense(node, :keyword, message(node.loc.keyword.source))
+          add_offense(node, :keyword, format(MSG, node.keyword))
         end
 
         private
 
         def autocorrect(node)
-          ->(corrector) { corrector.replace(node.source_range, oneline(node)) }
+          lambda do |corrector|
+            corrector.replace(node.source_range, to_modifier_form(node))
+          end
         end
 
         def eligible_node?(node)
           !non_eligible_if?(node) && !node.chained? &&
-            !nested_conditional?(node) && single_line_as_modifier?(node)
+            !node.nested_conditional? && single_line_as_modifier?(node)
         end
 
         def non_eligible_if?(node)
-          ternary?(node) || modifier_if?(node) ||
-            elsif?(node) || if_else?(node)
-        end
-
-        def message(keyword)
-          "Favor modifier `#{keyword}` usage when having a single-line body." \
-          ' Another good alternative is the usage of control flow `&&`/`||`.'
+          node.ternary? || node.modifier_form? || node.elsif? || node.else?
         end
 
         def parenthesize?(node)
@@ -60,21 +59,13 @@ module RuboCop
           source =~ /\s*\(\s*$/
         end
 
-        # returns false if the then or else children are conditionals
-        def nested_conditional?(node)
-          node.children[1, 2].compact.any?(&:if_type?)
-        end
-
-        def oneline(node)
-          cond, body, _else = if_node_parts(node)
-
-          expr = "#{body.source} #{node.loc.keyword.source} " + cond.source
-          if (comment_after = first_line_comment(node))
-            expr << ' ' << comment_after
-          end
-          expr = "(#{expr})" if parenthesize?(node)
+        def to_modifier_form(node)
+          expression = [node.body.source,
+                        node.keyword,
+                        node.condition.source,
+                        first_line_comment(node)].compact.join(' ')
 
-          expr
+          parenthesize?(node) ? "(#{expression})" : expression
         end
 
         def first_line_comment(node)

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

@@ -25,18 +25,12 @@ module RuboCop
       class IfUnlessModifierOfIfUnless < Cop
         include StatementModifier
 
-        MESSAGE = 'Avoid modifier `%s` after another conditional.'.freeze
-
-        def message(keyword)
-          format(MESSAGE, keyword)
-        end
+        MSG = 'Avoid modifier `%s` after another conditional.'.freeze
 
         def on_if(node)
-          return unless modifier_if?(node)
-          _cond, body, _else = if_node_parts(node)
-          return unless body.if_type?
+          return unless node.modifier_form? && node.body.if_type?
 
-          add_offense(node, :keyword, message(node.loc.keyword.source))
+          add_offense(node, :keyword, format(MSG, node.keyword))
         end
       end
     end

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

@@ -63,7 +63,7 @@ module RuboCop
           return if ignored_node?(array_node)
 
           left_bracket = array_node.loc.begin
-          first_elem = array_node.children.first
+          first_elem = array_node.values.first
           if first_elem
             return if first_elem.source_range.line == left_bracket.line
             check_first(first_elem, left_bracket, left_parenthesis, 0)

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

@@ -12,12 +12,11 @@ module RuboCop
       #     puts 'hello'
       #    end
       #   end
-      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
+      class IndentationWidth < Cop
         include EndKeywordAlignment
         include AutocorrectAlignment
         include OnMethodDef
         include CheckAssignment
-        include IfNode
         include AccessModifierNode
 
         SPECIAL_MODIFIERS = %w(private protected).freeze
@@ -67,18 +66,6 @@ module RuboCop
           check_members(node.loc.keyword, members)
         end
 
-        def check_members(base, members)
-          check_indentation(base, members.first)
-
-          return unless members.any? && members.first.begin_type?
-          return unless indentation_consistency_style == 'rails'
-
-          each_member(members) do |member, previous_modifier|
-            check_indentation(previous_modifier, member,
-                              indentation_consistency_style)
-          end
-        end
-
         def on_send(node)
           super
           return unless modifier_and_def_on_same_line?(node)
@@ -87,7 +74,7 @@ module RuboCop
           *_, body = *args.first
 
           def_end_config = config.for_cop('Lint/DefEndAlignment')
-          style = def_end_config['AlignWith'] || 'start_of_line'
+          style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
           base = style == 'def' ? args.first : node
 
           check_indentation(base.source_range, body)
@@ -99,67 +86,49 @@ module RuboCop
         end
 
         def on_for(node)
-          _variable, _collection, body = *node
-          check_indentation(node.loc.keyword, body)
+          check_indentation(node.loc.keyword, node.body)
         end
 
         def on_while(node, base = node)
           return if ignored_node?(node)
 
-          _condition, body = *node
-          return unless node.loc.keyword.begin_pos ==
-                        node.source_range.begin_pos
+          return unless node.single_line_condition?
 
-          check_indentation(base.loc, body)
+          check_indentation(base.loc, node.body)
         end
 
         alias on_until on_while
 
-        def on_case(node)
-          _condition, *branches = *node
-          latest_when = nil
-          branches.compact.each do |b|
-            if b.when_type?
-              # TODO: Revert to the original expression once the fix in Rubinius
-              #   is released.
-              #
-              # Originally this expression was:
-              #
-              #   *_conditions, body = *b
-              #
-              # However it fails on Rubinius 2.2.9 due to its bug:
-              #
-              #   RuntimeError:
-              #     can't modify frozen instance of Array
-              #   # kernel/common/array.rb:988:in `pop'
-              #   # ./lib/rubocop/cop/style/indentation_width.rb:99:in `on_case'
-              #
-              # It seems to be fixed on the current master (0a92c3c).
-              body = b.children.last
-
-              # Check "when" body against "when" keyword indentation.
-              check_indentation(b.loc.keyword, body)
-              latest_when = b
-            else
-              # Since it's not easy to get the position of the "else" keyword,
-              # we check "else" body against latest "when" keyword indentation.
-              check_indentation(latest_when.loc.keyword, b)
-            end
+        def on_case(case_node)
+          case_node.each_when do |when_node|
+            check_indentation(when_node.loc.keyword, when_node.body)
           end
+
+          check_indentation(case_node.when_branches.last.loc.keyword,
+                            case_node.else_branch)
         end
 
         def on_if(node, base = node)
-          return if ignored_node?(node)
-          return if ternary?(node)
-          return if modifier_if?(node)
-
-          _condition, body, else_clause = if_node_parts(node)
+          return if ignored_node?(node) || !node.body
+          return if node.ternary? || node.modifier_form?
 
-          check_if(node, body, else_clause, base.loc) if body
+          check_if(node, node.body, node.else_branch, base.loc)
         end
 
         private
 
+        def check_members(base, members)
+          check_indentation(base, members.first)
+
+          return unless members.any? && members.first.begin_type?
+          return unless indentation_consistency_style == 'rails'
+
+          each_member(members) do |member, previous_modifier|
+            check_indentation(previous_modifier, member,
+                              indentation_consistency_style)
+          end
+        end
+
         def each_member(members)
           previous_modifier = nil
           members.first.children.each do |member|
@@ -188,7 +157,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
 
           case rhs.type
@@ -201,14 +170,14 @@ module RuboCop
         end
 
         def check_if(node, body, else_clause, base_loc)
-          return if ternary?(node)
+          return if node.ternary?
 
           check_indentation(base_loc, body)
           return unless else_clause
 
           # If the else clause is an elsif, it will get its own on_if call so
           # we don't need to process it here.
-          return if elsif?(else_clause)
+          return if else_clause.if_type? && else_clause.elsif?
 
           check_indentation(node.loc.else, else_clause)
         end