rubocop 0.60.0 → 0.61.0

data/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -27,22 +27,13 @@ module RuboCop
         include RangeHelp
 
         def on_block(node)
-          return unless node.arguments?
+          arguments = node.arguments
 
-          args = node.arguments
+          return unless node.arguments? && pipes?(arguments)
 
-          opening_pipe = args.loc.begin
-          closing_pipe = args.loc.end
-          return if opening_pipe.nil? || closing_pipe.nil?
-
-          check_inside_pipes(args.children, opening_pipe, closing_pipe)
-
-          if node.body
-            check_space(closing_pipe.end_pos, node.body.source_range.begin_pos,
-                        closing_pipe, 'after closing `|`')
-          end
-
-          check_each_arg(args)
+          check_inside_pipes(arguments)
+          check_after_closing_pipe(arguments) if node.body
+          check_each_arg(arguments)
         end
 
         def autocorrect(range)
@@ -56,18 +47,40 @@ module RuboCop
 
         private
 
+        def pipes(arguments)
+          [arguments.loc.begin, arguments.loc.end]
+        end
+
+        def pipes?(arguments)
+          pipes(arguments).none?(&:nil?)
+        end
+
         def style_parameter_name
           'EnforcedStyleInsidePipes'
         end
 
-        def check_inside_pipes(args, opening_pipe, closing_pipe)
+        def check_inside_pipes(arguments)
+          opening_pipe, closing_pipe = pipes(arguments)
+
           if style == :no_space
-            check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+            check_no_space_style_inside_pipes(arguments.children,
+                                              opening_pipe,
+                                              closing_pipe)
           elsif style == :space
-            check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
+            check_space_style_inside_pipes(arguments.children,
+                                           opening_pipe,
+                                           closing_pipe)
           end
         end
 
+        def check_after_closing_pipe(arguments)
+          _opening_pipe, closing_pipe = pipes(arguments)
+          block = arguments.parent
+
+          check_space(closing_pipe.end_pos, block.body.source_range.begin_pos,
+                      closing_pipe, 'after closing `|`')
+        end
+
         def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
           first = args.first.source_range
           last = args.last.source_range

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -29,6 +29,7 @@ module RuboCop
         SHOVEL = '<<'.freeze
         PERCENT = '%'.freeze
         PERCENT_PERCENT = '%%'.freeze
+        DIGIT_DOLLAR_FLAG = /%(\d+)\$/.freeze
         STRING_TYPES = %i[str dstr].freeze
         NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/.freeze
 
@@ -132,6 +133,10 @@ module RuboCop
           return :unknown unless node.str_type?
           return 1 if node.source =~ NAMED_INTERPOLATION
 
+          max_digit_dollar_num = max_digit_dollar_num(node)
+          return max_digit_dollar_num if max_digit_dollar_num &&
+                                         max_digit_dollar_num.nonzero?
+
           node
             .source
             .scan(FIELD_REGEX)
@@ -139,6 +144,12 @@ module RuboCop
             .reduce(0) { |acc, elem| acc + arguments_count(elem[2]) }
         end
 
+        def max_digit_dollar_num(node)
+          node.source.scan(DIGIT_DOLLAR_FLAG).map do |digit_dollar_num|
+            digit_dollar_num.first.to_i
+          end.max
+        end
+
         # number of arguments required for the format sequence
         def arguments_count(format)
           format.scan('*').count + 1

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -86,11 +86,8 @@ module RuboCop
         end
 
         def contains_multiple_levels_of_exceptions?(group)
-          if group.size > 1 && group.include?(Exception)
-            # Treat `Exception` as the highest level exception unless `nil` was
-            # also rescued
-            return !(group.size == 2 && group.include?(NilClass))
-          end
+          # Always treat `Exception` as the highest level exception.
+          return true if group.size > 1 && group.include?(Exception)
 
           group.combination(2).any? do |a, b|
             compare_exceptions(a, b)

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -134,7 +134,7 @@ module RuboCop
 
           if node.begin_type?
             check_scope(node)
-          elsif node.send_type? && access_modifier?(node)
+          elsif node.send_type? && node.bare_access_modifier?
             add_offense(node, message: format(MSG, current: node.method_name))
           end
         end

data/lib/rubocop/cop/metrics/line_length.rb

@@ -63,7 +63,7 @@ module RuboCop
 
         def ignored_line?(line, index, heredocs)
           matches_ignored_pattern?(line) ||
-            heredocs && line_in_whitelisted_heredoc?(heredocs, index.succ)
+            heredocs && line_in_permitted_heredoc?(heredocs, index.succ)
         end
 
         def register_offense(loc, line)
@@ -107,7 +107,7 @@ module RuboCop
           end
         end
 
-        def line_in_whitelisted_heredoc?(heredocs, line_number)
+        def line_in_permitted_heredoc?(heredocs, line_number)
           heredocs.any? do |range, delimiter|
             range.cover?(line_number) &&
               (allowed_heredoc == true || allowed_heredoc.include?(delimiter))

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

@@ -89,31 +89,27 @@ module RuboCop
       # on different lines, each item within is on its own line, and the
       # closing bracket is on its own line.
       def multiline?(node)
-        # No need to process anything if the whole node is not multiline
-        # Without the 2nd check, Foo.new({}) is considered multiline, which
-        # it should not be. Essentially, if there are no elements, the
-        # expression can not be multiline.
-        return false unless node.multiline?
-
-        items = elements(node).map(&:source_range)
-        return false if items.empty?
+        node.multiline? && !allowed_multiline_argument?(node)
+      end
 
-        items << node.loc.begin << node.loc.end
-        (items.map(&:first_line) + items.map(&:last_line)).uniq.size > 1
+      # A single argument with the closing bracket on the same line as the end
+      # of the argument is not considered multiline, even if the argument
+      # itself might span multiple lines.
+      def allowed_multiline_argument?(node)
+        elements(node).one? && !Util.begins_its_line?(node.loc.end)
       end
 
       def elements(node)
         return node.children unless node.send_type?
 
-        _receiver, _method_name, *args = *node
-        args.flat_map do |a|
+        node.arguments.flat_map do |argument|
           # For each argument, if it is a multi-line hash without braces,
           # then promote the hash elements to method arguments
           # for the purpose of determining multi-line-ness.
-          if a.hash_type? && a.multiline? && !a.braces?
-            a.children
+          if argument.hash_type? && argument.multiline? && !argument.braces?
+            argument.children
           else
-            a
+            argument
           end
         end
       end

data/lib/rubocop/cop/offense.rb

@@ -24,7 +24,7 @@ module RuboCop
       # @return [Parser::Source::Range]
       #   the location where the violation is detected.
       #
-      # @see http://rubydoc.info/github/whitequark/parser/Parser/Source/Range
+      # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range
       #   Parser::Source::Range
       attr_reader :location
 

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for `OpenStruct.new` calls.
+      # Instantiation of an `OpenStruct` invalidates
+      # Ruby global method cache as it causes dynamic method
+      # definition during program runtime.
+      # This could have an effect on performance,
+      # especially in case of single-threaded
+      # applications with multiple `OpenStruct` instantiations.
+      #
+      # @example
+      #   # bad
+      #   class MyClass
+      #     def my_method
+      #       OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #     MyStruct = Struct.new(:my_key1, :my_key2)
+      #     def my_method
+      #       MyStruct.new('my_value1', 'my_value2')
+      #     end
+      #   end
+      #
+      class OpenStruct < Cop
+        MSG = 'Consider using `Struct` over `OpenStruct` ' \
+              'to optimize the performance.'.freeze
+
+        def_node_matcher :open_struct, <<-PATTERN
+          (send (const {nil? cbase} :OpenStruct) :new ...)
+        PATTERN
+
+        def on_send(node)
+          open_struct(node) do |method|
+            add_offense(node, location: :selector, message: format(MSG, method))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,6 +14,12 @@ module RuboCop
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'.freeze
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
+        WITH_MODIFIER_CORRECTION = <<-RUBY.strip_indent
+          %<keyword>s %<condition>s
+          %<leading_space>s%<indent>s%<body>s
+          %<leading_space>send
+        RUBY
+
         def_node_matcher :redundant_merge_candidate, <<-PATTERN
           (send $!nil? :merge! [(hash $...) !kwsplat_type?])
         PATTERN
@@ -60,6 +66,7 @@ module RuboCop
 
         def non_redundant_merge?(node, receiver, pairs)
           non_redundant_pairs?(receiver, pairs) ||
+            kwsplat_used?(pairs) ||
             non_redundant_value_used?(receiver, node)
         end
 
@@ -67,6 +74,10 @@ module RuboCop
           pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
         end
 
+        def kwsplat_used?(pairs)
+          pairs.any?(&:kwsplat_type?)
+        end
+
         def non_redundant_value_used?(receiver, node)
           node.value_used? &&
             !EachWithObjectInspector.new(node, receiver).value_used?
@@ -101,12 +112,15 @@ module RuboCop
         end
 
         def rewrite_with_modifier(node, parent, new_source)
-          cond, = *parent
-          padding = "\n#{(' ' * indent_width) + leading_spaces(node)}"
+          indent = ' ' * indent_width
+          padding = "\n#{indent + leading_spaces(node)}"
           new_source.gsub!(/\n/, padding)
 
-          parent.loc.keyword.source << ' ' << cond.source << padding <<
-            new_source << "\n" << leading_spaces(node) << 'end'
+          format(WITH_MODIFIER_CORRECTION, keyword: parent.loc.keyword.source,
+                                           condition: parent.condition.source,
+                                           leading_space: leading_spaces(node),
+                                           indent: indent,
+                                           body: new_source).chomp
         end
 
         def leading_spaces(node)

data/lib/rubocop/cop/rails/bulk_change_table.rb

@@ -63,8 +63,8 @@ module RuboCop
       #     end
       #   end
       #
-      # @see http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
-      # @see http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
       class BulkChangeTable < Cop
         MSG_FOR_CHANGE_TABLE = <<-MSG.strip_indent.chomp
           You can combine alter queries using `bulk: true` options.

data/lib/rubocop/cop/rails/dynamic_find_by.rb

@@ -44,22 +44,29 @@ module RuboCop
         end
 
         def autocorrect(node)
-          _receiver, method, *args = *node
-          static_name = static_method_name(method.to_s)
-          keywords = column_keywords(method)
+          keywords = column_keywords(node.method_name)
 
-          return if keywords.size != args.size
+          return if keywords.size != node.arguments.size
 
           lambda do |corrector|
-            corrector.replace(node.loc.selector, static_name)
-            keywords.each.with_index do |keyword, idx|
-              corrector.insert_before(args[idx].loc.expression, keyword)
-            end
+            autocorrect_method_name(corrector, node)
+            autocorrect_argument_keywords(corrector, node, keywords)
           end
         end
 
         private
 
+        def autocorrect_method_name(corrector, node)
+          corrector.replace(node.loc.selector,
+                            static_method_name(node.method_name.to_s))
+        end
+
+        def autocorrect_argument_keywords(corrector, node, keywords)
+          keywords.each.with_index do |keyword, idx|
+            corrector.insert_before(node.arguments[idx].loc.expression, keyword)
+          end
+        end
+
         def whitelist
           cop_config['Whitelist']
         end

data/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -52,19 +52,9 @@ module RuboCop
         # the data is the http parameters and environment sent in
         # the Rails 5 http call
         def autocorrect(node)
-          http_path, *data = *node.arguments
-
-          controller_action = http_path.source
-          params = convert_hash_data(data.first, 'params')
-          session = convert_hash_data(data.last, 'session') if data.size > 1
-          # the range of the text to replace, which is the whole line
-          code_to_replace = node.loc.expression
-          # what to replace with
-          format = parentheses_format(node)
-          new_code = format(format, name: node.method_name,
-                                    action: controller_action,
-                                    params: params, session: session)
-          ->(corrector) { corrector.replace(code_to_replace, new_code) }
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, correction(node))
+          end
         end
 
         private
@@ -101,7 +91,20 @@ module RuboCop
           format(', %<type>s: %<hash_data>s', type: type, hash_data: hash_data)
         end
 
-        def parentheses_format(node)
+        def correction(node)
+          http_path, *data = *node.arguments
+
+          controller_action = http_path.source
+          params = convert_hash_data(data.first, 'params')
+          session = convert_hash_data(data.last, 'session') if data.size > 1
+
+          format(correction_template(node), name: node.method_name,
+                                            action: controller_action,
+                                            params: params,
+                                            session: session)
+        end
+
+        def correction_template(node)
           if parentheses?(node)
             '%<name>s(%<action>s%<params>s%<session>s)'
           else

data/lib/rubocop/cop/rails/http_status.rb

@@ -143,7 +143,7 @@ module RuboCop
                 'to define HTTP status code.'.freeze
           DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
                         'to define HTTP status code.'.freeze
-          WHITELIST_STATUS = %i[error success missing redirect].freeze
+          PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node
           def initialize(node)
@@ -151,7 +151,7 @@ module RuboCop
           end
 
           def offensive?
-            !node.int_type? && !whitelisted_symbol?
+            !node.int_type? && !permitted_symbol?
           end
 
           def message
@@ -176,8 +176,8 @@ module RuboCop
             node.value
           end
 
-          def whitelisted_symbol?
-            node.sym_type? && WHITELIST_STATUS.include?(node.value)
+          def permitted_symbol?
+            node.sym_type? && PERMITTED_STATUS.include?(node.value)
           end
         end
       end

data/lib/rubocop/cop/rails/inverse_of.rb

@@ -128,8 +128,8 @@ module RuboCop
       #     has_many :physicians, through: :appointments
       #   end
       #
-      # @see http://guides.rubyonrails.org/association_basics.html#bi-directional-associations
-      # @see http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
+      # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
       class InverseOf < Cop
         extend TargetRailsVersion
 

data/lib/rubocop/cop/rails/reversible_migration.rb

@@ -124,7 +124,7 @@ module RuboCop
       #     end
       #   end
       #
-      # @see http://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
       class ReversibleMigration < Cop
         MSG = '%<action>s is not reversible.'.freeze
         IRREVERSIBLE_CHANGE_TABLE_CALLS = %i[

data/lib/rubocop/cop/rails/skips_model_validations.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Rails
       # This cop checks for the use of methods which skip
       # validations which are listed in
-      # http://guides.rubyonrails.org/active_record_validations.html#skipping-validations
+      # https://guides.rubyonrails.org/active_record_validations.html#skipping-validations
       #
       # Methods may be ignored from this rule by configuring a `Whitelist`.
       #