rubocop 0.40.0 → 0.41.0

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

@@ -11,6 +11,7 @@ module RuboCop
       def check_brace_layout(node)
         return unless node.loc.begin # Ignore implicit literals.
         return if children(node).empty? # Ignore empty literals.
+        return if node.single_line? # Ignore single-line literals.
 
         # If the last node is or contains a conflicting HEREDOC, we don't want
         # to adjust the brace layout because this will result in invalid code.
@@ -32,7 +33,8 @@ module RuboCop
           lambda do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.end,
                                                           :left))
-            corrector.insert_after(children(node).last.source_range,
+
+            corrector.insert_after(last_element_range_with_trailing_comma(node),
                                    node.loc.end.source)
           end
         end
@@ -40,6 +42,21 @@ module RuboCop
 
       private
 
+      def last_element_range_with_trailing_comma(node)
+        trailing_comma_range = last_element_trailing_comma_range(node)
+        if trailing_comma_range
+          children(node).last.source_range.join(trailing_comma_range)
+        else
+          children(node).last.source_range
+        end
+      end
+
+      def last_element_trailing_comma_range(node)
+        range = range_with_surrounding_space(children(node).last.source_range,
+                                             :right).end.resize(1)
+        range.source == ',' ? range : nil
+      end
+
       def handle_new_line(node)
         return unless closing_brace_on_same_line?(node)
 

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

@@ -6,17 +6,19 @@ module RuboCop
     # Some common code shared between FavorUnlessOverNegatedIf and
     # FavorUntilOverNegatedWhile.
     module NegativeConditional
+      def self.included(mod)
+        mod.def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+      end
+
       def check_negative_conditional(node)
         condition, _body, _rest = *node
 
         # Look at last expression of contents if there are parentheses
         # around condition.
         condition = condition.children.last while condition.type == :begin
-        return unless condition.type == :send
 
-        _object, method = *condition
-        return unless method == :! && !(node.loc.respond_to?(:else) &&
-                                        node.loc.else)
+        return unless single_negative?(condition) &&
+                      !(node.loc.respond_to?(:else) && node.loc.else)
 
         add_offense(node, :expression)
       end

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

@@ -22,6 +22,16 @@ module RuboCop
       def type(node)
         node.loc.begin.source[0..-2]
       end
+
+      # 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
+        )
+      end
     end
   end
 end

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

@@ -9,16 +9,34 @@ module RuboCop
       MSG = 'Space missing after %s.'.freeze
 
       def investigate(processed_source)
-        processed_source.tokens.each_cons(2) do |t1, t2|
-          next unless kind(t1) && t1.pos.line == t2.pos.line &&
-                      t2.pos.column == t1.pos.column + offset &&
-                      ![:tRPAREN, :tRBRACK, :tPIPE].include?(t2.type) &&
-                      !(t2.type == :tRCURLY && space_forbidden_before_rcurly?)
+        each_missing_space(processed_source.tokens) do |token|
+          add_offense(token, token.pos, format(MSG, kind(token)))
+        end
+      end
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |t1, t2|
+          next unless kind(t1)
+          next unless space_missing?(t1, t2)
+          next unless space_required_before?(t2)
 
-          add_offense(t1, t1.pos, format(MSG, kind(t1)))
+          yield t1
         end
       end
 
+      def space_missing?(t1, t2)
+        t1.pos.line == t2.pos.line && t2.pos.column == t1.pos.column + offset
+      end
+
+      def space_required_before?(token)
+        !(allowed_type?(token) ||
+          (token.type == :tRCURLY && space_forbidden_before_rcurly?))
+      end
+
+      def allowed_type?(token)
+        [:tRPAREN, :tRBRACK, :tPIPE].include?(token.type)
+      end
+
       def space_forbidden_before_rcurly?
         style = space_style_before_rcurly
         style == 'no_space'

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

@@ -9,21 +9,34 @@ module RuboCop
       MSG = 'Space found before %s.'.freeze
 
       def investigate(processed_source)
-        processed_source.tokens.each_cons(2) do |t1, t2|
-          next unless kind(t2) && t1.pos.line == t2.pos.line &&
-                      t2.pos.begin_pos > t1.pos.end_pos &&
-                      !(t1.type == :tLCURLY && space_required_after_lcurly?)
+        each_missing_space(processed_source.tokens) do |token, pos_before|
+          add_offense(pos_before, pos_before, format(MSG, kind(token)))
+        end
+      end
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |t1, t2|
+          next unless kind(t2)
+          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)
 
-          add_offense(pos_before_punctuation,
-                      pos_before_punctuation,
-                      format(MSG, kind(t2)))
+          yield t2, pos_before_punctuation
         end
       end
 
+      def space_missing?(t1, t2)
+        t1.pos.line == t2.pos.line && t2.pos.begin_pos > t1.pos.end_pos
+      end
+
+      def space_required_after?(token)
+        token.type == :tLCURLY && space_required_after_lcurly?
+      end
+
       def space_required_after_lcurly?
         cfg = config.for_cop('Style/SpaceInsideBlockBraces')
         style = cfg['EnforcedStyle'] || 'space'

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

@@ -11,9 +11,9 @@ module RuboCop
         src = node.source
         return false if src.start_with?('%', '?')
         if style == :single_quotes
-          src !~ /'/ && !double_quotes_acceptable?(node.str_content)
+          !double_quotes_required?(src)
         else
-          src !~ /" | \\ | \#/x
+          src !~ /" | \\ | \#(@|\{)/x
         end
       end
 

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

@@ -23,26 +23,39 @@ module RuboCop
         comma_offset = after_last_item.source =~ /,/
 
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
-          unless should_have_comma?(style, node)
-            extra_info = case style
-                         when :comma
-                           ', unless each item is on its own line'
-                         when :consistent_comma
-                           ', unless items are split onto multiple lines'
-                         else
-                           ''
-                         end
-            avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
-                        extra_info)
-          end
+          check_comma(node, kind, after_last_item.begin_pos + comma_offset)
         elsif should_have_comma?(style, node)
           put_comma(node, items, kind, sb)
         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)
+      end
+
+      def extra_avoid_comma_info
+        case style
+        when :comma
+          ', unless each item is on its own line'
+        when :consistent_comma
+          ', unless items are split onto multiple lines'
+        else
+          ''
+        end
+      end
+
       def should_have_comma?(style, node)
-        [:comma, :consistent_comma].include?(style) &&
+        case style
+        when :comma
+          multiline?(node) && no_elements_on_same_line?(node)
+        when :consistent_comma
           multiline?(node)
+        else
+          false
+        end
       end
 
       def inside_comment?(range, comma_offset)
@@ -73,13 +86,8 @@ module RuboCop
 
         items = elements(node).map(&:source_range)
         return false if items.empty?
-
-        # If brackets are on different lines and there is one item at least,
-        # then comma is needed anytime for consistent_comma.
-        return true if style == :consistent_comma
-
-        items << node.loc.end
-        items.each_cons(2).all? { |a, b| !on_same_line?(a, b) }
+        items << node.loc.begin << node.loc.end
+        (items.map(&:first_line) + items.map(&:last_line)).uniq.count > 1
       end
 
       def elements(node)
@@ -99,6 +107,12 @@ module RuboCop
         end
       end
 
+      def no_elements_on_same_line?(node)
+        items = elements(node).map(&:source_range)
+        items << node.loc.end
+        items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
+      end
+
       def on_same_line?(a, b)
         a.last_line == b.line
       end

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

@@ -25,23 +25,17 @@ module RuboCop
         def on_send(node)
           left, second_method, flatten_param = *node
           return unless FLATTEN.include?(second_method)
+
           flatten_level, = *flatten_param
           expression, = *left
           _array, first_method = *expression
           return unless first_method == :map || first_method == :collect
 
-          message = MSG
           if cop_config['EnabledForFlattenWithoutParams'] && flatten_level.nil?
-            message = MSG + FLATTEN_MULTIPLE_LEVELS
-          elsif flatten_level != 1
-            return
+            offense_for_levels(node, expression, first_method, second_method)
+          elsif flatten_level == 1
+            offense_for_method(node, expression, first_method, second_method)
           end
-
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            expression.loc.selector.begin_pos,
-                                            node.loc.selector.end_pos)
-
-          add_offense(node, range, format(message, first_method, second_method))
         end
 
         def autocorrect(node)
@@ -60,6 +54,25 @@ module RuboCop
             corrector.replace(array.loc.selector, 'flat_map')
           end
         end
+
+        private
+
+        def offense_for_levels(node, expression, first_method, second_method)
+          message = MSG + FLATTEN_MULTIPLE_LEVELS
+          offense(node, expression, first_method, second_method, message)
+        end
+
+        def offense_for_method(node, expression, first_method, second_method)
+          offense(node, expression, first_method, second_method, MSG)
+        end
+
+        def offense(node, expression, first_method, second_method, message)
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            expression.loc.selector.begin_pos,
+                                            node.loc.selector.end_pos)
+
+          add_offense(node, range, format(message, first_method, second_method))
+        end
       end
     end
   end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of
+      #
+      # @example
+      #   # bad
+      #   [].push(*a)
+      #
+      #   # good
+      #   [].concat(a)
+      class PushSplat < Cop
+        include Parentheses
+
+        MSG = 'Use `concat` instead of `push(*)`.'.freeze
+
+        def_node_matcher :push_splat, <<-END
+          (send _ :push (splat ...))
+        END
+
+        def on_send(node)
+          push_splat(node) do
+            add_offense(node, :expression, MSG)
+          end
+        end
+
+        def autocorrect(node)
+          _receiver, _method, splat = *node
+          body, = *splat
+          lambda do |corrector|
+            corrector.replace(node.location.selector, 'concat')
+
+            source = if parens_required?(splat)
+                       "(#{body.source})"
+                     else
+                       body.source
+                     end
+            corrector.replace(splat.loc.expression, source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -39,15 +39,38 @@ module RuboCop
           (send (lvar %1) :call ...)
         END
 
+        def_node_search :blockarg_assigned?, <<-END
+          (lvasgn %1 ...)
+        END
+
         def on_def(node)
           blockarg_def(node) do |argname, body|
             next unless body
-            blockarg_calls(body, argname) do |blockcall|
+
+            calls_to_report(argname, body).each do |blockcall|
               add_offense(blockcall, :expression, format(MSG, argname))
             end
           end
         end
 
+        private
+
+        def calls_to_report(argname, body)
+          return [] if blockarg_assigned?(body, argname)
+
+          calls = to_enum(:blockarg_calls, body, argname)
+
+          return [] if calls.any? { |call| args_include_block_pass?(call) }
+
+          calls
+        end
+
+        def args_include_block_pass?(blockcall)
+          _receiver, _call, *args = *blockcall
+
+          args.any?(&:block_pass_type?)
+        end
+
         # offenses are registered on the `block.call` nodes
         def autocorrect(node)
           _receiver, _method, *args = *node

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

@@ -16,7 +16,9 @@ module RuboCop
         MSG = 'Use `%s` instead of `%s`.'.freeze
 
         def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
-        def_node_matcher :modifier_flow_control, '[{if while until} #modifier?]'
+        def_node_matcher :modifier_flow_control, <<-END
+          [{if while until} modifier_form?]
+        END
         def_node_matcher :each_with_object_node, <<-END
           (block (send _ :each_with_object _) (args _ $_) ...)
         END
@@ -110,10 +112,6 @@ module RuboCop
           @config.for_cop('IndentationWidth')['Width'] || 2
         end
 
-        def modifier?(node)
-          node.loc.respond_to?(:end) && node.loc.end.nil?
-        end
-
         def max_key_value_pairs
           cop_config['MaxKeyValuePairs'].to_i
         end

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

@@ -111,20 +111,24 @@ module RuboCop
           def sample_size
             _, _, *args = *method_node
             case args.size
-            when 1
-              arg = args.first
-              case arg.type
-              when :erange, :irange then range_size(arg)
-              when :int             then arg.to_a.first.zero? ? nil : :unknown
-              else :unknown
-              end
-            when 2
-              first, second = *args
-              return :unknown unless first.int_type? && first.to_a.first.zero?
-              second.int_type? ? second.to_a.first : :unknown
+            when 1 then sample_size_for_one_arg(args.first)
+            when 2 then sample_size_for_two_args(*args)
             end
           end
 
+          def sample_size_for_one_arg(arg)
+            case arg.type
+            when :erange, :irange then range_size(arg)
+            when :int             then arg.to_a.first.zero? ? nil : :unknown
+            else :unknown
+            end
+          end
+
+          def sample_size_for_two_args(first, second)
+            return :unknown unless first.int_type? && first.to_a.first.zero?
+            second.int_type? ? second.to_a.first : :unknown
+          end
+
           def shuffle_arg
             _, _, arg = *shuffle_node
             arg.source if arg