rubocop 0.42.0 → 0.43.0

data/lib/rubocop/cop/mixin/percent_literal.rb

@@ -26,11 +26,7 @@ module RuboCop
       # A range containing only the contents of the percent literal (e.g. in
       # %i{1 2 3} this will be the range covering '1 2 3' only)
       def contents_range(node)
-        Parser::Source::Range.new(
-          node.loc.expression.source_buffer,
-          node.loc.begin.end_pos,
-          node.loc.end.begin_pos
-        )
+        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
     end
   end

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -22,14 +22,24 @@ module RuboCop
         # minus 2 because node.loc.line is zero-based
         pre  = (range.line - 2).downto(0)
         post = range.line.upto(processed_source.lines.size - 1)
-        return true if aligned_with_line?(pre, range, &predicate) ||
-                       aligned_with_line?(post, range, &predicate)
+
+        aligned_with_any_line_range?([pre, post], range, &predicate)
+      end
+
+      def aligned_with_any_line_range?(line_ranges, range, &predicate)
+        return true if aligned_with_any_line?(line_ranges, range, &predicate)
 
         # If no aligned token was found, search for an aligned token on the
         # nearest line with the same indentation as the checked line.
         base_indentation = processed_source.lines[range.line - 1] =~ /\S/
-        aligned_with_line?(pre, range, base_indentation, &predicate) ||
-          aligned_with_line?(post, range, base_indentation, &predicate)
+
+        aligned_with_any_line?(line_ranges, range, base_indentation, &predicate)
+      end
+
+      def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate)
+        line_ranges.any? do |line_nos|
+          aligned_with_line?(line_nos, range, indent, &predicate)
+        end
       end
 
       def aligned_with_line?(line_nos, range, indent = nil)

data/lib/rubocop/cop/mixin/safe_mode.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Rails safe mode.
+    module SafeMode
+      private
+
+      def rails_safe_mode?
+        safe_mode? || rails?
+      end
+
+      def safe_mode?
+        cop_config['SafeMode']
+      end
+
+      def rails?
+        config['Rails'] && config['Rails']['Enabled']
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -20,10 +20,8 @@ module RuboCop
           next unless space_missing?(t1, t2)
           next if space_required_after?(t1)
 
-          buffer = processed_source.buffer
-          pos_before_punctuation = Parser::Source::Range.new(buffer,
-                                                             t1.pos.end_pos,
-                                                             t2.pos.begin_pos)
+          pos_before_punctuation = range_between(t1.pos.end_pos,
+                                                 t2.pos.begin_pos)
 
           yield t2, pos_before_punctuation
         end

data/lib/rubocop/cop/mixin/space_inside.rb

@@ -41,9 +41,7 @@ module RuboCop
       end
 
       def range_between_tokens(t1, t2)
-        Parser::Source::Range.new(processed_source.buffer,
-                                  t1.pos.end_pos,
-                                  t2.pos.begin_pos)
+        range_between(t1.pos.end_pos, t2.pos.begin_pos)
       end
 
       # Wraps info about the brackets. Makes it easy to check whether a token

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -7,18 +7,32 @@ module RuboCop
     module StatementModifier
       include IfNode
 
-      def fit_within_line_as_modifier_form?(node)
-        cond, body, _else = if_node_parts(node)
+      def single_line_as_modifier?(node)
+        cond, body, = if_node_parts(node)
 
-        return false if length(node) > 3
-        return false if body && body.begin_type? # multiple statements
+        return false if non_eligible_node?(node) || non_eligible_body?(body) ||
+                        non_eligible_condition?(cond)
 
-        body_length = body_length(body)
+        modifier_fits_on_single_line?(node)
+      end
+
+      def non_eligible_node?(node)
+        line_count(node) > 3 || commented?(node.loc.end)
+      end
+
+      def non_eligible_body?(body)
+        return true unless body
+
+        body.begin_type? || empty_body?(body) || commented?(body.source_range)
+      end
+
+      def non_eligible_condition?(condition)
+        condition.each_node.any?(&:lvasgn_type?)
+      end
 
-        return false if body_length.zero?
-        return false if cond.each_node.any?(&:lvasgn_type?)
-        return false if body_has_comment?(body)
-        return false if end_keyword_has_comment?(node)
+      def modifier_fits_on_single_line?(node)
+        cond, body, = if_node_parts(node)
+        body_length = body_length(body)
 
         length_in_modifier_form(node, cond, body_length) <= max_line_length
       end
@@ -36,24 +50,20 @@ module RuboCop
           config.for_cop('Metrics/LineLength')['Max']
       end
 
-      def length(node)
+      def line_count(node)
         node.source.lines.grep(/\S/).size
       end
 
-      def body_length(body)
-        if body && body.source_range
-          body.source_range.size
-        else
-          0
-        end
+      def empty_body?(body)
+        body_length(body).zero?
       end
 
-      def body_has_comment?(body)
-        comment_lines.include?(body.source_range.line)
+      def body_length(body)
+        body.source_range ? body.source_range.size : 0
       end
 
-      def end_keyword_has_comment?(node)
-        comment_lines.include?(node.loc.end.line)
+      def commented?(source)
+        comment_lines.include?(source.line)
       end
 
       def comment_lines

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -15,8 +15,7 @@ module RuboCop
       end
 
       def check(node, items, kind, begin_pos, end_pos)
-        sb = node.source_range.source_buffer
-        after_last_item = Parser::Source::Range.new(sb, begin_pos, end_pos)
+        after_last_item = range_between(begin_pos, end_pos)
 
         return if heredoc?(after_last_item.source)
 
@@ -25,15 +24,14 @@ module RuboCop
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
         elsif should_have_comma?(style, node)
-          put_comma(node, items, kind, sb)
+          put_comma(node, items, kind)
         end
       end
 
       def check_comma(node, kind, comma_pos)
         return if should_have_comma?(style, node)
 
-        avoid_comma(kind, comma_pos, node.source_range.source_buffer,
-                    extra_avoid_comma_info)
+        avoid_comma(kind, comma_pos, extra_avoid_comma_info)
       end
 
       def extra_avoid_comma_info
@@ -117,30 +115,34 @@ module RuboCop
         a.last_line == b.line
       end
 
-      def avoid_comma(kind, comma_begin_pos, sb, extra_info)
-        range = Parser::Source::Range.new(sb, comma_begin_pos,
-                                          comma_begin_pos + 1)
+      def avoid_comma(kind, comma_begin_pos, extra_info)
+        range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind =~ /array/ ? 'an' : 'a'
         add_offense(range, range,
                     format(MSG, 'Avoid', format(kind, article)) +
                     "#{extra_info}.")
       end
 
-      def put_comma(node, items, kind, sb)
+      def put_comma(node, items, kind)
+        return if avoid_autocorrect?(elements(node))
+
         last_item = items.last
-        return if last_item.type == :block_pass
+        return if last_item.block_pass_type?
 
-        last_expr = last_item.source_range
-        ix = last_expr.source.rindex("\n") || 0
-        ix += last_expr.source[ix..-1] =~ /\S/
-        range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
-                                          last_expr.end_pos)
-        autocorrect_range = avoid_autocorrect?(elements(node)) ? nil : range
+        range = autocorrect_range(last_item)
 
-        add_offense(autocorrect_range, range,
+        add_offense(range, range,
                     format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
       end
 
+      def autocorrect_range(item)
+        expr = item.source_range
+        ix = expr.source.rindex("\n") || 0
+        ix += expr.source[ix..-1] =~ /\S/
+
+        range_between(expr.begin_pos + ix, expr.end_pos)
+      end
+
       # By default, there's no reason to avoid auto-correct.
       def avoid_autocorrect?(_)
         false

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -94,37 +94,20 @@ module RuboCop
         private
 
         def replacement(conditions)
-          new_condition = conditions.map do |condition|
-            variable, = *condition
-            if variable.respond_to?(:array_type?) && variable.array_type?
-              expand_percent_array(variable)
-            else
-              condition.source
-            end
-          end
-
+          new_condition = conditions.map(&:source)
           new_condition.join(', ')
         end
 
-        def inline_fix_branch(corrector, node, conditions, new_condition)
-          range =
-            Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                      conditions[0].loc.expression.begin_pos,
-                                      conditions[-1].loc.expression.end_pos)
+        def inline_fix_branch(corrector, _node, conditions, new_condition)
+          range = range_between(conditions[0].loc.expression.begin_pos,
+                                conditions[-1].loc.expression.end_pos)
           corrector.replace(range, new_condition)
         end
 
         def reorder_condition(corrector, node, new_condition)
           *_conditions, body = *node
-          parent = node.parent
-          _case_branch, *when_branches, _else_branch = *parent
-          current_index = when_branches.index { |branch| branch == node }
-          next_branch = when_branches[current_index + 1]
-          range = Parser::Source::Range.new(parent,
-                                            node.source_range.begin_pos,
-                                            next_branch.source_range.begin_pos)
-
-          corrector.remove(range)
+          _case_branch, *when_branches, _else_branch = *node.parent
+          corrector.remove(when_branch_range(node, when_branches))
 
           correction = if same_line?(node, body)
                          new_condition_with_then(node, new_condition)
@@ -135,6 +118,14 @@ module RuboCop
           corrector.insert_after(when_branches.last.source_range, correction)
         end
 
+        def when_branch_range(node, when_branches)
+          current_index = when_branches.index { |branch| branch == node }
+          next_branch = when_branches[current_index + 1]
+
+          range_between(node.source_range.begin_pos,
+                        next_branch.source_range.begin_pos)
+        end
+
         def same_line?(node, other)
           node.loc.first_line == other.loc.first_line
         end
@@ -155,6 +146,8 @@ module RuboCop
             found_non_splat ||= error_condition?(condition)
 
             next unless condition.splat_type?
+            variable, = *condition
+            next if variable.array_type?
             result << condition if found_non_splat
           end
         end
@@ -172,24 +165,6 @@ module RuboCop
             condition.splat_type? && !(variable && variable.array_type?)
           end
         end
-
-        def expand_percent_array(array)
-          array_start = array.loc.begin.source
-          elements = *array
-          elements = elements.map(&:source)
-
-          if array_start.start_with?(PERCENT_W)
-            "'#{elements.join("', '")}'"
-          elsif array_start.start_with?(PERCENT_CAPITAL_W)
-            %("#{elements.join('", "')}")
-          elsif array_start.start_with?(PERCENT_I)
-            ":#{elements.join(', :')}"
-          elsif array_start.start_with?(PERCENT_CAPITAL_I)
-            %(:"#{elements.join('", :"')}")
-          else
-            elements.join(', ')
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/performance/casecmp.rb

@@ -39,22 +39,9 @@ module RuboCop
         def on_send(node)
           return if part_of_ignored_node?(node)
 
-          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
-            *_, method = *other
-            if CASE_METHODS.include?(method)
-              range = node.loc.expression
-              ignore_node(node)
-            else
-              range = node.loc.selector.join(send_downcase.loc.selector)
-            end
-
-            add_offense(node, range, format(MSG, case_method, eq_method))
-            return
-          end
-
-          eq_downcase(node) do |eq_method, send_downcase, case_method|
-            range = node.loc.selector.join(send_downcase.loc.selector)
-            add_offense(node, range, format(MSG, eq_method, case_method))
+          inefficient_comparison(node) do |range, is_other_part, *methods|
+            ignore_node(node) if is_other_part
+            add_offense(node, range, format(MSG, *methods))
           end
         end
 
@@ -74,6 +61,31 @@ module RuboCop
 
         private
 
+        def inefficient_comparison(node)
+          loc = node.loc
+
+          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
+            *_, method = *other
+            range, is_other_part = downcase_eq_range(method, loc, send_downcase)
+
+            yield range, is_other_part, case_method, eq_method
+            return
+          end
+
+          eq_downcase(node) do |eq_method, send_downcase, case_method|
+            range = loc.selector.join(send_downcase.loc.selector)
+            yield range, false, eq_method, case_method
+          end
+        end
+
+        def downcase_eq_range(method, loc, send_downcase)
+          if CASE_METHODS.include?(method)
+            [loc.expression, true]
+          else
+            [loc.selector.join(send_downcase.loc.selector), false]
+          end
+        end
+
         def correction(node, _receiver, method, arg, variable)
           lambda do |corrector|
             corrector.insert_before(node.loc.expression, '!') if method == :!=

data/lib/rubocop/cop/performance/count.rb

@@ -39,24 +39,32 @@ module RuboCop
       #
       #   Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
       class Count < Cop
+        include SafeMode
+
         MSG = 'Use `count` instead of `%s...%s`.'.freeze
 
         SELECTORS = [:reject, :select].freeze
         COUNTERS = [:count, :length, :size].freeze
 
         def on_send(node)
-          return unless should_run?
-          selector, selector_loc, params, counter = parse(node)
-          return unless COUNTERS.include?(counter)
-          return unless SELECTORS.include?(selector)
-          return if params && !params.block_pass_type?
-          return if node.parent && node.parent.block_type?
-
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            selector_loc.begin_pos,
-                                            node.source_range.end_pos)
-
-          add_offense(node, range, format(MSG, selector, counter))
+          return if rails_safe_mode?
+
+          @selector, @selector_loc, @params, @counter = parse(node)
+
+          check(node)
+        end
+
+        private
+
+        attr_reader :selector, :selector_loc, :params, :counter
+
+        def check(node)
+          return unless eligible_node?(node) && eligible_params? &&
+                        eligible_method_chain?
+
+          range = source_starting_at(node) { @selector_loc.begin_pos }
+
+          add_offense(node, range, format(MSG, @selector, @counter))
         end
 
         def autocorrect(node)
@@ -64,9 +72,7 @@ module RuboCop
 
           return if selector == :reject
 
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            node.loc.dot.begin_pos,
-                                            node.source_range.end_pos)
+          range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
 
           lambda do |corrector|
             corrector.remove(range)
@@ -74,37 +80,55 @@ module RuboCop
           end
         end
 
-        private
+        def eligible_node?(node)
+          !(node.parent && node.parent.block_type?)
+        end
 
-        def should_run?
-          !(cop_config['SafeMode'.freeze] ||
-            config['Rails'.freeze] &&
-            config['Rails'.freeze]['Enabled'.freeze])
+        def eligible_params?
+          !(params && !params.block_pass_type?)
         end
 
-        def parse(node)
-          left, counter = *node
-          expression, selector, params = *left
-
-          selector_loc =
-            if selector.is_a?(Symbol)
-              if expression && expression.parent.loc.respond_to?(:selector)
-                expression.parent.loc.selector
-              elsif left.loc.respond_to?(:selector)
-                left.loc.selector
-              end
-            else
-              _enumerable, selector, params = *expression
+        def eligible_method_chain?
+          COUNTERS.include?(counter) && SELECTORS.include?(selector)
+        end
 
-              expression.loc.selector if contains_selector?(expression)
+        def parse(node)
+          head, counter = *node
+          expression, selector, params = *head
+          if selector.is_a?(Symbol)
+            selector_loc = selector_location(expression, head.loc)
+          else
+            _, selector, params = *expression
+            if contains_selector?(expression)
+              selector_loc = expression.loc.selector
             end
+          end
 
           [selector, selector_loc, params, counter]
         end
 
+        def selector_location(expression, head_loc)
+          if expression && expression.parent.loc.respond_to?(:selector)
+            expression.parent.loc.selector
+          elsif head_loc.respond_to?(:selector)
+            head_loc.selector
+          end
+        end
+
         def contains_selector?(node)
           node.respond_to?(:loc) && node.loc.respond_to?(:selector)
         end
+
+        def source_starting_at(node)
+          begin_pos =
+            if block_given?
+              yield node
+            else
+              node.source_range.begin_pos
+            end
+
+          range_between(begin_pos, node.source_range.end_pos)
+        end
       end
     end
   end