rubocop 0.42.0 → 0.43.0

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

@@ -101,13 +101,11 @@ module RuboCop
         end
 
         def args?(node)
-          args = node_args(node)
-          args.children.count > 0
+          !node_args(node).children.empty?
         end
 
         def parentheses?(node)
-          args = node_args(node)
-          args.loc.begin
+          node_args(node).loc.begin
         end
       end
     end

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

@@ -26,16 +26,16 @@ module RuboCop
         end
 
         def validate_config
-          if style == :percent && target_ruby_version < 2.0
-            raise ValidationError, 'The default `percent` style for the ' \
-                                  '`Style/SymbolArray` cop is only compatible' \
-                                  ' with Ruby 2.0 and up, but the target Ruby' \
-                                  " version for your project is 1.9.\nPlease " \
-                                  'either disable this cop, configure it to ' \
-                                  'use `array` style, or adjust the ' \
-                                  '`TargetRubyVersion` parameter in your ' \
-                                  'configuration.'
-          end
+          return unless style == :percent && target_ruby_version < 2.0
+
+          raise ValidationError, 'The default `percent` style for the ' \
+                                '`Style/SymbolArray` cop is only compatible' \
+                                ' with Ruby 2.0 and up, but the target Ruby' \
+                                " version for your project is 1.9.\nPlease " \
+                                'either disable this cop, configure it to ' \
+                                'use `array` style, or adjust the ' \
+                                '`TargetRubyVersion` parameter in your ' \
+                                'configuration.'
         end
 
         private

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

@@ -57,10 +57,9 @@ module RuboCop
         end
 
         def offense(node, method_name, block_method_name)
-          sb = node.source_range.source_buffer
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
-          range = Parser::Source::Range.new(sb, block_start, block_end)
+          range = range_between(block_start, block_end)
 
           add_offense(node,
                       range,
@@ -91,9 +90,7 @@ module RuboCop
         end
 
         def block_range_with_space(node)
-          block_range =
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      begin_pos_for_replacement(node),
+          block_range = range_between(begin_pos_for_replacement(node),
                                       node.loc.end.end_pos)
           range_with_surrounding_space(block_range, :left)
         end
@@ -118,16 +115,15 @@ module RuboCop
         end
 
         def can_shorten?(block_args, block_body)
-          # something { |x, y| ... }
-          return false unless block_args.children.size == 1
-          return false if non_shortenable_args?(block_args)
-          return false unless block_body && block_body.type == :send
+          return false unless shortenable_args?(block_args) &&
+                              shortenable_body?(block_body)
 
-          receiver, _method_name, args = *block_body
+          argument_matches_receiver?(block_args, block_body)
+        end
 
-          # method in block must be invoked on a lvar without args
-          return false if args
-          return false unless receiver && receiver.type == :lvar
+        # TODO: This might be clearer as a node matcher with unification
+        def argument_matches_receiver?(block_args, block_body)
+          receiver, = *block_body
 
           block_arg_name, = *block_args.children.first
           receiver_name, = *receiver
@@ -135,6 +131,25 @@ module RuboCop
           block_arg_name == receiver_name
         end
 
+        # The block body must have a single send without arguments to an
+        # lvar type.
+        # E.g.: `foo { |bar| bar.baz }`
+        def shortenable_body?(block_body)
+          return false unless block_body && block_body.send_type?
+
+          receiver, _, args = *block_body
+
+          return false if args
+
+          receiver && receiver.lvar_type?
+        end
+
+        # The block must have a single, shortenable argument.
+        # E.g.: `foo { |bar| ... }`
+        def shortenable_args?(block_args)
+          block_args.children.one? && !non_shortenable_args?(block_args)
+        end
+
         def super?(node)
           [:super, :zsuper].include?(node.type)
         end

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

@@ -4,13 +4,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the presence of arentheses around ternary
+      # This cop checks for the presence of parentheses around ternary
       # conditions. It is configurable to enforce inclusion or omission of
       # parentheses using `EnforcedStyle`.
       #
       # @example
       #
-      #   EnforcedStyle: require_no_parentheses (deafault)
+      #   EnforcedStyle: require_no_parentheses (default)
       #
       #   @bad
       #   foo = (bar?) ? a : b
@@ -55,7 +55,8 @@ module RuboCop
 
           (require_parentheses? && !parenthesized?(condition) ||
             !require_parentheses? && parenthesized?(condition)) &&
-            !(safe_assignment?(condition) && safe_assignment_allowed?)
+            !(safe_assignment?(condition) && safe_assignment_allowed?) &&
+            !infinite_loop?
         end
 
         def autocorrect(node)
@@ -66,8 +67,8 @@ module RuboCop
               corrector.insert_before(condition.source_range, '(')
               corrector.insert_after(condition.source_range, ')')
             else
-              # Don't correct if it's a safe assignment
-              unless safe_assignment?(condition)
+              unless safe_assignment?(condition) ||
+                     unsafe_autocorrect?(condition)
                 corrector.remove(condition.loc.begin)
                 corrector.remove(condition.loc.end)
               end
@@ -85,9 +86,38 @@ module RuboCop
           style == :require_parentheses
         end
 
+        def redundant_parentheses_enabled?
+          @config.for_cop('RedundantParentheses')['Enabled']
+        end
+
         def parenthesized?(node)
           node.source =~ /^\(.*\)$/
         end
+
+        # When this cop is configured to enforce parentheses and the
+        # `RedundantParentheses` cop is enabled, it will cause an infinite loop
+        # as they compete to add and remove the parentheses respectively.
+        def infinite_loop?
+          require_parentheses? &&
+            redundant_parentheses_enabled?
+        end
+
+        def unsafe_autocorrect?(condition)
+          condition.children.any? do |child|
+            unparenthesized_method_call?(child)
+          end
+        end
+
+        def unparenthesized_method_call?(child)
+          argument = method_call_argument(child)
+
+          argument && argument !~ /^\(/
+        end
+
+        def_node_matcher :method_call_argument, <<-PATTERN
+          {(:defined? $...)
+           (send {(send ...) nil} _ $(send nil _)...)}
+        PATTERN
       end
     end
   end

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

@@ -34,11 +34,9 @@ module RuboCop
         def offense_detected(sb, wanted_blank_lines, blank_lines,
                              whitespace_at_end)
           begin_pos = sb.source.length - whitespace_at_end.length
-          autocorrect_range = Parser::Source::Range.new(sb, begin_pos,
-                                                        sb.source.length)
+          autocorrect_range = range_between(begin_pos, sb.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
-          report_range = Parser::Source::Range.new(sb, begin_pos,
-                                                   sb.source.length)
+          report_range = range_between(begin_pos, sb.source.length)
           add_offense(autocorrect_range, report_range,
                       message(wanted_blank_lines, blank_lines))
         end

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

@@ -26,7 +26,9 @@ module RuboCop
         UNDERSCORE = '_'.freeze
 
         def on_masgn(node)
-          return unless (range = unneeded_range(node))
+          range = unneeded_range(node)
+
+          return unless range
 
           good_code = node.source
           offset = range.begin_pos - node.source_range.begin_pos
@@ -36,8 +38,9 @@ module RuboCop
         end
 
         def autocorrect(node)
+          range = unneeded_range(node)
+
           lambda do |corrector|
-            range = unneeded_range(node)
             corrector.remove(range) if range
           end
         end
@@ -45,27 +48,38 @@ module RuboCop
         private
 
         def find_first_offense(variables)
-          first_offense = nil
+          first_offense = find_first_possible_offense(variables.reverse)
+
+          return unless first_offense
+          return if splat_variable_before?(first_offense, variables)
+
+          first_offense
+        end
 
-          variables.reverse_each do |variable|
+        def find_first_possible_offense(variables)
+          variables.reduce(nil) do |offense, variable|
             var, = *variable
             var, = *var
             if allow_named_underscore_variables
-              break unless var == :_
+              break offense unless var == :_
             else
-              break unless var.to_s.start_with?(UNDERSCORE)
+              break offense unless var.to_s.start_with?(UNDERSCORE)
             end
-            first_offense = variable
+
+            variable
           end
+        end
 
-          return nil if first_offense.nil?
+        def splat_variable_before?(first_offense, variables)
+          # Account for cases like `_, *rest, _`, where we would otherwise get
+          # the index of the first underscore.
+          first_offense_index = reverse_index(variables, first_offense)
 
-          first_offense_index = variables.index(first_offense)
-          0.upto(first_offense_index - 1).each do |index|
-            return nil if variables[index].splat_type?
-          end
+          variables[0...first_offense_index].any?(&:splat_type?)
+        end
 
-          first_offense
+        def reverse_index(collection, item)
+          collection.size - 1 - collection.reverse.index(item)
         end
 
         def allow_named_underscore_variables
@@ -87,10 +101,8 @@ module RuboCop
               node.loc.operator.begin_pos
             end
 
-          range =
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      first_offense.source_range.begin_pos,
-                                      end_position)
+          range = range_between(first_offense.source_range.begin_pos,
+                                end_position)
           range_with_surrounding_space(range, :right)
         end
       end

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

@@ -85,7 +85,7 @@ module RuboCop
         end
 
         def looks_like_trivial_reader?(args, body)
-          args.children.empty? && body && body.type == :ivar
+          args.children.empty? && body && body.ivar_type?
         end
 
         def trivial_writer?(method_name, args, body)
@@ -95,10 +95,10 @@ module RuboCop
         end
 
         def looks_like_trivial_writer?(args, body)
-          args.children.size == 1 &&
+          args.children.one? &&
             ![:restarg, :blockarg].include?(args.children[0].type) &&
-            body && body.type == :ivasgn &&
-            body.children[1] && body.children[1].type == :lvar
+            body && body.ivasgn_type? &&
+            body.children[1] && body.children[1].lvar_type?
         end
 
         def allowed_method?(method_name, body)
@@ -134,9 +134,9 @@ module RuboCop
         end
 
         def autocorrect(node)
-          if node.type == :def
+          if node.def_type?
             autocorrect_instance(node)
-          elsif node.type == :defs && node.children.first.type == :self
+          elsif node.defs_type? && node.children.first.self_type?
             autocorrect_class(node)
           end
         end

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

@@ -32,15 +32,11 @@ module RuboCop
         end
 
         def range_between_condition_and_else(node, condition)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    condition.source_range.end_pos,
-                                    node.loc.else.begin_pos)
+          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
         end
 
         def range_between_else_and_end(node)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.else.end_pos,
-                                    node.loc.end.begin_pos)
+          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
         end
       end
     end

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

@@ -18,11 +18,15 @@ module RuboCop
         private
 
         def on_percent_literal(node)
-          requires_interpolation = node.children.any? do |string|
-            string.type == :dstr ||
-              double_quotes_acceptable?(string.str_content)
+          return if requires_interpolation?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def requires_interpolation?(node)
+          node.child_nodes.any? do |string|
+            string.dstr_type? || double_quotes_acceptable?(string.str_content)
           end
-          add_offense(node, :expression) unless requires_interpolation
         end
 
         def autocorrect(node)

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

@@ -39,11 +39,11 @@ module RuboCop
         end
 
         def single_child?(node)
-          node.children.size == 1
+          node.children.one?
         end
 
         def interpolation?(node)
-          variable_interpolation?(node) || node.type == :begin
+          variable_interpolation?(node) || node.begin_type?
         end
 
         def variable_interpolation?(node)
@@ -51,12 +51,11 @@ module RuboCop
         end
 
         def implicit_concatenation?(node)
-          node.parent && node.parent.type == :dstr
+          node.parent && node.parent.dstr_type?
         end
 
         def embedded_in_percent_array?(node)
-          node.parent &&
-            node.parent.type == :array &&
+          node.parent && node.parent.array_type? &&
             percent_literal?(node.parent)
         end
 

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

@@ -33,16 +33,22 @@ module RuboCop
         private
 
         def check(node)
-          src = node.source
-          return unless start_with_percent_q_variant?(src)
-          return if src.include?(SINGLE_QUOTE) && src.include?(QUOTE)
-          return if src.start_with?(PERCENT_Q) && acceptable_q?(node)
-          return if src.start_with?(PERCENT_CAPITAL_Q) &&
-                    acceptable_capital_q?(node)
+          return unless start_with_percent_q_variant?(node)
+          return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
           add_offense(node, :expression)
         end
 
+        def interpolated_quotes?(node)
+          node.source.include?(SINGLE_QUOTE) && node.source.include?(QUOTE)
+        end
+
+        def allowed_percent_q?(node)
+          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
+            node.source.start_with?(PERCENT_CAPITAL_Q) &&
+              acceptable_capital_q?(node)
+        end
+
         def message(node)
           src = node.source
           extra = if src.start_with?(PERCENT_CAPITAL_Q)
@@ -68,7 +74,7 @@ module RuboCop
         end
 
         def start_with_percent_q_variant?(string)
-          string.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
+          string.source.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
         end
 
         def acceptable_q?(node)

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop makes sure that all numbered variables use the
+      # configured style, snake_case, normalcase or non_integer,
+      # for their numbering.
+      #
+      # @example
+      #   "EnforcedStyle => 'snake_case'"
+      #
+      #   # bad
+      #
+      #   variable1 = 1
+      #
+      #   # good
+      #
+      #   variable_1 = 1
+      #
+      # @example
+      #   "EnforcedStyle => 'normalcase'"
+      #
+      #   # bad
+      #
+      #   variable_1 = 1
+      #
+      #   # good
+      #
+      #   variable1 = 1
+      #
+      # @example
+      #   "EnforcedStyle => 'non_integer'"
+      #
+      #   #bad
+      #
+      #   variable1 = 1
+      #
+      #   variable_1 = 1
+      #
+      #   #good
+      #
+      #   variableone = 1
+      #
+      #   variable_one = 1
+      #
+      class VariableNumber < Cop
+        include ConfigurableNumbering
+
+        def on_lvasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_ivasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_cvasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_arg(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        private
+
+        def message(style)
+          format('Use %s for variable numbers.', style)
+        end
+      end
+    end
+  end
+end