rubocop 0.42.0 → 0.43.0

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

@@ -26,7 +26,7 @@ module RuboCop
 
         def on_alias(node)
           # alias_method can't be used with global variables
-          return if node.children.any?(&:gvar_type?)
+          return if node.each_child_node(:gvar).any?
           # alias_method can't be used in instance_eval blocks
           scope_type = scope_type(node)
           return if scope_type == :instance_eval

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

@@ -189,7 +189,7 @@ module RuboCop
         end
 
         def hash?(node)
-          node.respond_to?(:type) && node.type == :hash
+          node.respond_to?(:type) && node.hash_type?
         end
 
         def explicit_hash?(node)
@@ -205,25 +205,38 @@ module RuboCop
         end
 
         def autocorrect(node)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. A local variable fixes the problem.
+          key_delta = @column_deltas[:key] || 0
+          key, value = *node
+
+          if value.nil?
+            correct_no_value(key_delta, node.source_range)
+          else
+            correct_key_value(key_delta, key.source_range, value.source_range,
+                              node.loc.operator)
+          end
+        end
+
+        def correct_no_value(key_delta, key)
+          ->(corrector) { adjust(corrector, key_delta, key) }
+        end
+
+        def correct_key_value(key_delta, key, value, separator)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. Some local variables fix the problem.
-          key_delta       = @column_deltas[:key] || 0
           separator_delta = @column_deltas[:separator] || 0
           value_delta     = @column_deltas[:value] || 0
 
-          key, value = *node
-          key_column = key.source_range.column
+          key_column = key.column
           key_delta = -key_column if key_delta < -key_column
 
           lambda do |corrector|
-            if value.nil?
-              adjust(corrector, key_delta, node.source_range)
-            else
-              adjust(corrector, key_delta, key.source_range)
-              adjust(corrector, separator_delta, node.loc.operator)
-              adjust(corrector, value_delta, value.source_range)
-            end
+            adjust(corrector, key_delta, key)
+            adjust(corrector, separator_delta, separator)
+            adjust(corrector, value_delta, value)
           end
         end
 
@@ -240,9 +253,7 @@ module RuboCop
           if delta > 0
             corrector.insert_before(range, ' ' * delta)
           elsif delta < 0
-            range = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos - delta.abs,
-                                              range.begin_pos)
+            range = range_between(range.begin_pos - delta.abs, range.begin_pos)
             corrector.remove(range)
           end
         end

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

@@ -60,7 +60,7 @@ module RuboCop
 
         def autocorrect(node)
           expr1, expr2 = *node
-          replacement = (node.type == :and ? '&&' : '||')
+          replacement = (node.and_type? ? '&&' : '||')
           lambda do |corrector|
             [expr1, expr2].each do |expr|
               if expr.send_type?
@@ -78,12 +78,19 @@ module RuboCop
         def correct_send(node, corrector)
           receiver, method_name, *args = *node
           return correct_not(node, receiver, corrector) if method_name == :!
+          return correct_setter(node, corrector) if setter_method?(method_name)
           return unless correctable_send?(node)
 
           corrector.replace(whitespace_before_arg(node), '('.freeze)
           corrector.insert_after(args.last.source_range, ')'.freeze)
         end
 
+        def correct_setter(node, corrector)
+          receiver, _method_name, *args = *node
+          corrector.insert_before(receiver.source_range, '('.freeze)
+          corrector.insert_after(args.last.source_range, ')'.freeze)
+        end
+
         # ! is a special case:
         # 'x and !obj.method arg' can be auto-corrected if we
         # recurse down a level and add parens to 'obj.method arg'
@@ -106,6 +113,10 @@ module RuboCop
           corrector.insert_after(node.source_range, ')')
         end
 
+        def setter_method?(method_name)
+          method_name.to_s.end_with?('=')
+        end
+
         def correctable_send?(node)
           _receiver, method_name, *args = *node
           # don't clobber if we already have a starting paren
@@ -117,13 +128,12 @@ module RuboCop
         end
 
         def whitespace_before_arg(node)
-          sb = node.source_range.source_buffer
           begin_paren = node.loc.selector.end_pos
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).
           end_paren += 1 unless node.source =~ /\?[!\S]/
-          Parser::Source::Range.new(sb, begin_paren, end_paren)
+          range_between(begin_paren, end_paren)
         end
       end
     end

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

@@ -14,8 +14,8 @@ module RuboCop
 
         def on_send(node)
           receiver_node, method_name, *arg_nodes = *node
-          return unless receiver_node && receiver_node.type == :array &&
-                        method_name == :* && arg_nodes[0].type == :str
+          return unless receiver_node && receiver_node.array_type? &&
+                        method_name == :* && arg_nodes.first.str_type?
 
           add_offense(node, :selector)
         end
@@ -23,7 +23,7 @@ module RuboCop
         def autocorrect(node)
           receiver_node, _method_name, *arg_nodes = *node
           array = receiver_node.source
-          join_arg = arg_nodes[0].source
+          join_arg = arg_nodes.first.source
 
           lambda do |corrector|
             corrector.replace(node.source_range, "#{array}.join(#{join_arg})")

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

@@ -27,8 +27,7 @@ module RuboCop
                            comment.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
-          Parser::Source::Range.new(comment.loc.expression.source_buffer,
-                                    start_position, end_position)
+          range_between(start_position, end_position)
         end
 
         def first_non_ascii_chars(string)

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

@@ -25,8 +25,7 @@ module RuboCop
                            identifier.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
-          Parser::Source::Range.new(identifier.pos.source_buffer,
-                                    start_position, end_position)
+          range_between(start_position, end_position)
         end
 
         def first_non_ascii_chars(string)

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

@@ -20,9 +20,7 @@ module RuboCop
           attr_expr = attr_name.source_range
 
           if setter && (setter.true_type? || setter.false_type?)
-            remove = Parser::Source::Range.new(node_expr.source_buffer,
-                                               attr_expr.end_pos,
-                                               node_expr.end_pos)
+            remove = range_between(attr_expr.end_pos, node_expr.end_pos)
           end
 
           lambda do |corrector|

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

@@ -37,12 +37,8 @@ module RuboCop
         def parts(comment)
           expr = comment.loc.expression
           eq_begin = expr.resize(BEGIN_LENGTH)
-          eq_end = Parser::Source::Range.new(expr.source_buffer,
-                                             expr.end_pos - END_LENGTH,
-                                             expr.end_pos)
-          contents = Parser::Source::Range.new(expr.source_buffer,
-                                               eq_begin.end_pos,
-                                               eq_end.begin_pos)
+          eq_end = range_between(expr.end_pos - END_LENGTH, expr.end_pos)
+          contents = range_between(eq_begin.end_pos, eq_end.begin_pos)
           [eq_begin, eq_end, contents]
         end
       end

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

@@ -6,7 +6,7 @@ module RuboCop
     module Style
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
-      class BlockDelimiters < Cop # rubocop:disable Metrics/ClassLength
+      class BlockDelimiters < Cop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
@@ -73,20 +73,34 @@ module RuboCop
         def autocorrect(node)
           return if correction_would_break_code?(node)
 
+          if node.loc.begin.is?('{')
+            replace_braces_with_do_end(node.loc)
+          else
+            replace_do_end_with_braces(node.loc)
+          end
+        end
+
+        def replace_braces_with_do_end(loc)
+          b = loc.begin
+          e = loc.end
+
           lambda do |corrector|
-            b = node.loc.begin
-            e = node.loc.end
-            if b.is?('{')
-              corrector.insert_before(b, ' ') unless whitespace_before?(b)
-              corrector.insert_before(e, ' ') unless whitespace_before?(e)
-              corrector.insert_after(b, ' ') unless whitespace_after?(b)
-              corrector.replace(b, 'do')
-              corrector.replace(e, 'end')
-            else
-              corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
-              corrector.replace(b, '{')
-              corrector.replace(e, '}')
-            end
+            corrector.insert_before(b, ' ') unless whitespace_before?(b)
+            corrector.insert_before(e, ' ') unless whitespace_before?(e)
+            corrector.insert_after(b, ' ') unless whitespace_after?(b)
+            corrector.replace(b, 'do')
+            corrector.replace(e, 'end')
+          end
+        end
+
+        def replace_do_end_with_braces(loc)
+          b = loc.begin
+          e = loc.end
+
+          lambda do |corrector|
+            corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
+            corrector.replace(b, '{')
+            corrector.replace(e, '}')
           end
         end
 
@@ -160,13 +174,13 @@ module RuboCop
         end
 
         def correction_would_break_code?(node)
-          if node.loc.begin.is?('do')
-            # Converting `obj.method arg do |x| end` to use `{}` would cause
-            # a syntax error.
-            send = node.children.first
-            _receiver, _method_name, *args = *send
-            !args.empty? && !parentheses?(send)
-          end
+          return unless node.loc.begin.is?('do')
+
+          # Converting `obj.method arg do |x| end` to use `{}` would cause
+          # a syntax error.
+          send = node.children.first
+          _receiver, _method_name, *args = *send
+          !args.empty? && !parentheses?(send)
         end
 
         def ignored_method?(method_name)

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

@@ -39,13 +39,13 @@ module RuboCop
         end
 
         def check_context_dependent(arg, args)
-          braces_around_2nd_from_end = args.length > 1 && args[-2].type == :hash
+          braces_around_second_from_end = args.length > 1 && args[-2].hash_type?
           if braces?(arg)
-            unless braces_around_2nd_from_end
+            unless braces_around_second_from_end
               add_offense(arg.parent, arg.source_range,
                           format(MSG, 'Redundant'))
             end
-          elsif braces_around_2nd_from_end
+          elsif braces_around_second_from_end
             add_offense(arg.parent, arg.source_range, format(MSG, 'Missing'))
           end
         end
@@ -102,7 +102,7 @@ module RuboCop
         end
 
         def non_empty_hash?(arg)
-          arg && arg.type == :hash && arg.children.any?
+          arg && arg.hash_type? && !arg.children.empty?
         end
 
         def braces?(arg)

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

@@ -74,9 +74,7 @@ module RuboCop
           when_column = node.location.keyword.column
           begin_pos = node.loc.keyword.begin_pos
 
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    begin_pos - when_column,
-                                    begin_pos)
+          range_between(begin_pos - when_column, begin_pos)
         end
 
         def replacement(node)

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

@@ -39,11 +39,10 @@ module RuboCop
         def check(name, node)
           return unless node
 
-          if node.type == :defs
+          if node.defs_type?
             check_defs(name, node)
-          elsif node.type == :begin
-            defs_nodes = node.children.compact.select { |n| n.type == :defs }
-            defs_nodes.each { |n| check_defs(name, n) }
+          elsif node.begin_type?
+            node.each_child_node(:defs) { |n| check_defs(name, n) }
           end
         end
 

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

@@ -23,7 +23,7 @@ module RuboCop
 
         def on_send(node)
           _receiver, _method_name, *args = *node
-          return unless args.size == 1 && args.first.type == :block_pass
+          return unless args.one? && args.first.block_pass_type?
 
           check_method_node(node)
         end

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

@@ -46,23 +46,30 @@ module RuboCop
         private
 
         def check_backtick_literal(node)
-          return if style == :backticks && !contains_disallowed_backtick?(node)
-          return if style == :mixed &&
-                    node.single_line? &&
-                    !contains_disallowed_backtick?(node)
+          return if allowed_backtick_literal?(node)
 
           add_offense(node, :expression, MSG_USE_PERCENT_X)
         end
 
         def check_percent_x_literal(node)
-          return if style == :backticks && contains_disallowed_backtick?(node)
-          return if style == :percent_x
-          return if style == :mixed && node.multiline?
-          return if style == :mixed && contains_disallowed_backtick?(node)
+          return if allowed_percent_x_literal?(node)
 
           add_offense(node, :expression, MSG_USE_BACKTICKS)
         end
 
+        def allowed_backtick_literal?(node)
+          style == :backticks && !contains_disallowed_backtick?(node) ||
+            style == :mixed && node.single_line? &&
+              !contains_disallowed_backtick?(node)
+        end
+
+        def allowed_percent_x_literal?(node)
+          style == :backticks && contains_disallowed_backtick?(node) ||
+            style == :percent_x ||
+            style == :mixed && node.multiline? ||
+            style == :mixed && contains_disallowed_backtick?(node)
+        end
+
         def contains_disallowed_backtick?(node)
           !allow_inner_backticks? && contains_backtick?(node)
         end

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

@@ -47,8 +47,7 @@ module RuboCop
 
         def annotation_range(comment, margin, length)
           start = comment.loc.expression.begin_pos + margin.length
-          source_buffer = comment.loc.expression.source_buffer
-          Parser::Source::Range.new(source_buffer, start, start + length)
+          range_between(start, start + length)
         end
 
         def concat_length(*args)

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

@@ -32,7 +32,7 @@ module RuboCop
           branch.begin_type? ? [*branch].last : branch
         end
 
-        def lhs(node)
+        def lhs(node) # rubocop:disable Metrics/MethodLength
           case node.type
           when :send
             lhs_for_send(node)
@@ -77,17 +77,22 @@ module RuboCop
 
         def lhs_for_send(node)
           receiver = node.receiver.nil? ? '' : node.receiver.source
+          method_name = node.method_name
 
-          if node.method_name == :[]=
+          if method_name == :[]=
             indices = node.children[2...-1].map(&:source).join(', ')
             "#{receiver}[#{indices}] = "
-          elsif node.method_name.to_s.end_with?(EQUAL) &&
-                ![:!=, :==, :===, :>=, :<=].include?(node.method_name)
-            "#{receiver}.#{node.method_name[0...-1]} = "
+          elsif setter_method?(method_name)
+            "#{receiver}.#{method_name[0...-1]} = "
           else
-            "#{receiver} #{node.method_name} "
+            "#{receiver} #{method_name} "
           end
         end
+
+        def setter_method?(method_name)
+          method_name.to_s.end_with?(EQUAL) &&
+            ![:!=, :==, :===, :>=, :<=].include?(method_name)
+        end
       end
 
       # Check for `if` and `case` statements where each branch is used for
@@ -277,7 +282,7 @@ module RuboCop
         def assignment_node(node)
           *_variable, assignment = *node
 
-          if assignment.begin_type? && assignment.children.size == 1
+          if assignment.begin_type? && assignment.children.one?
             assignment, = *assignment
           end
 
@@ -337,18 +342,22 @@ module RuboCop
         end
 
         def check_node(node, branches)
-          return unless branches.all?
-          last_statements = branches.map { |branch| tail(branch) }
-          return unless lhs_all_match?(last_statements)
-          return if last_statements.any?(&:masgn_type?)
-          return unless assignment_types_match?(*last_statements)
-
+          return unless allowed_statements?(branches)
           return if single_line_conditions_only? && branches.any?(&:begin_type?)
           return if correction_exceeds_line_limit?(node, branches)
 
           add_offense(node, :expression)
         end
 
+        def allowed_statements?(branches)
+          return false unless branches.all?
+
+          statements = branches.map { |branch| tail(branch) }
+
+          lhs_all_match?(statements) && !statements.any?(&:masgn_type?) &&
+            assignment_types_match?(*statements)
+        end
+
         # If `Metrics/LineLength` is enabled, we do not want to introduce an
         # offense by auto-correcting this cop. Find the max configured line
         # length. Find the longest line of condition. Remove the assignment
@@ -357,16 +366,26 @@ module RuboCop
         # of the longest line + the length of the corrected assignment is
         # greater than the max configured line length
         def correction_exceeds_line_limit?(node, branches)
-          return false unless config.for_cop(LINE_LENGTH)[ENABLED]
+          return false unless line_length_cop_enabled?
+
           assignment = lhs(tail(branches[0]))
-          max_line_length = config.for_cop(LINE_LENGTH)[MAX]
-          indentation_width = config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
-          return true if longest_rhs(branches) + indentation_width +
-                         assignment.length > max_line_length
 
+          longest_rhs_exceeds_line_limit?(branches, assignment) ||
+            longest_line_exceeds_line_limit?(node, assignment)
+        end
+
+        def longest_rhs_exceeds_line_limit?(branches, assignment)
+          longest_rhs_full_length(branches, assignment) > max_line_length
+        end
+
+        def longest_line_exceeds_line_limit?(node, assignment)
           longest_line(node, assignment).length > max_line_length
         end
 
+        def longest_rhs_full_length(branches, assignment)
+          longest_rhs(branches) + indentation_width + assignment.length
+        end
+
         def longest_line(node, assignment)
           assignment_regex = /#{Regexp.escape(assignment).gsub(' ', '\s*')}/
           lines = node.source.lines.map do |line|
@@ -380,9 +399,16 @@ module RuboCop
           branches.map { |branch| branch.children.last.source.length }.max
         end
 
-        def lines_with_numbers(node)
-          line_nos = node.loc.line..node.loc.last_line
-          node.source.lines.zip(line_nos)
+        def line_length_cop_enabled?
+          config.for_cop(LINE_LENGTH)[ENABLED]
+        end
+
+        def max_line_length
+          config.for_cop(LINE_LENGTH)[MAX]
+        end
+
+        def indentation_width
+          config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
         end
 
         def single_line_conditions_only?
@@ -450,21 +476,8 @@ module RuboCop
           include ConditionalCorrectorHelper
 
           def correct(node)
-            condition, if_branch, else_branch = *node
-            _variable, *_operator, if_rhs = *if_branch
-            _else_variable, *_operator, else_rhs = *else_branch
-            condition = condition.source
-            if_rhs = if_rhs.source
-            else_rhs = else_rhs.source
-
-            ternary = "#{condition} ? #{if_rhs} : #{else_rhs}"
-            if if_branch.send_type? && if_branch.method_name != :[]=
-              ternary = "(#{ternary})"
-            end
-            correction = "#{lhs(if_branch)}#{ternary}"
-
             lambda do |corrector|
-              corrector.replace(node.source_range, correction)
+              corrector.replace(node.source_range, correction(node))
             end
           end
 
@@ -484,9 +497,28 @@ module RuboCop
 
           private
 
+          def correction(node)
+            condition, if_branch, else_branch = *node
+
+            "#{lhs(if_branch)}#{ternary(condition, if_branch, else_branch)}"
+          end
+
+          def ternary(condition, if_branch, else_branch)
+            _variable, *_operator, if_rhs = *if_branch
+            _else_variable, *_operator, else_rhs = *else_branch
+
+            expr = "#{condition.source} ? #{if_rhs.source} : #{else_rhs.source}"
+
+            element_assignment?(if_branch) ? "(#{expr})" : expr
+          end
+
+          def element_assignment?(node)
+            node.send_type? && node.method_name != :[]=
+          end
+
           def extract_branches(node)
             *_var, rhs = *node
-            condition, = *rhs if rhs.begin_type? && rhs.children.size == 1
+            condition, = *rhs if rhs.begin_type? && rhs.children.one?
             _condition, if_branch, else_branch = *(condition || rhs)
 
             [if_branch, else_branch]