rubocop 0.93.1 → 1.0.0

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

@@ -12,6 +12,9 @@ module RuboCop
         MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
               '[%<count>d/%<max>d]'
 
+        NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
+        private_constant :NAMED_KEYWORD_TYPES
+
         def on_args(node)
           count = args_count(node)
           return unless count > max_params
@@ -33,7 +36,7 @@ module RuboCop
           if count_keyword_args?
             node.children.size
           else
-            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) }
           end
         end
 

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -18,7 +18,7 @@ module RuboCop
               'name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
 
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)

data/lib/rubocop/cop/security/open.rb

@@ -3,35 +3,37 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#open`.
+      # This cop checks for the use of `Kernel#open` and `URI.open`.
       #
-      # `Kernel#open` enables not only file access but also process invocation
-      # by prefixing a pipe symbol (e.g., `open("| ls")`). So, it may lead to
-      # a serious security risk by using variable input to the argument of
-      # `Kernel#open`. It would be better to use `File.open`, `IO.popen` or
-      # `URI#open` explicitly.
+      # `Kernel#open` and `URI.open` enable not only file access but also process
+      # invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
+      # So, it may lead to a serious security risk by using variable input to
+      # the argument of `Kernel#open` and `URI.open`. It would be better to use
+      # `File.open`, `IO.popen` or `URI.parse#open` explicitly.
       #
       # @example
       #   # bad
       #   open(something)
+      #   URI.open(something)
       #
       #   # good
       #   File.open(something)
       #   IO.popen(something)
       #   URI.parse(something).open
       class Open < Base
-        MSG = 'The use of `Kernel#open` is a serious security risk.'
+        MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
         RESTRICT_ON_SEND = %i[open].freeze
 
         def_node_matcher :open?, <<~PATTERN
-          (send nil? :open $!str ...)
+          (send ${nil? (const {nil? cbase} :URI)} :open $!str ...)
         PATTERN
 
         def on_send(node)
-          open?(node) do |code|
+          open?(node) do |receiver, code|
             return if safe?(code)
 
-            add_offense(node.loc.selector)
+            message = format(MSG, receiver: receiver ? "#{receiver.source}." : 'Kernel#')
+            add_offense(node.loc.selector, message: message)
           end
         end
 

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

@@ -7,7 +7,7 @@ module RuboCop
       # By default it enforces accessors to be placed in grouped declarations,
       # but it can be configured to enforce separating them in multiple declarations.
       #
-      # Note: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
+      # NOTE: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
       # or disabling this cop.
       #
       # @example EnforcedStyle: grouped (default)

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

@@ -37,6 +37,27 @@ module RuboCop
       #
       #   # good
       #   format('%s', 'Hello')
+      #
+      # It is allowed to contain unannotated token
+      # if the number of them is less than or equals to
+      # `MaxUnannotatedPlaceholdersAllowed`.
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 0
+      #
+      #   # bad
+      #   format('%06d', 10)
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%<number>06d', number: 10)
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 1 (default)
+      #
+      #   # bad
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%06d', 10)
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
 
@@ -44,8 +65,12 @@ module RuboCop
           return unless node.value.include?('%')
           return if node.each_ancestor(:xstr, :regexp).any?
 
-          tokens(node) do |detected_style, token_range|
-            if detected_style == style || unannotated_format?(node, detected_style)
+          detections = collect_detections(node)
+          return if detections.empty?
+          return if allowed_unannotated?(detections)
+
+          detections.each do |detected_style, token_range|
+            if detected_style == style
               correct_style_detected
             else
               style_detected(detected_style)
@@ -112,6 +137,26 @@ module RuboCop
             yield(detected_style, token)
           end
         end
+
+        def collect_detections(node)
+          detections = []
+          tokens(node) do |detected_style, token_range|
+            unless unannotated_format?(node, detected_style)
+              detections << [detected_style, token_range]
+            end
+          end
+          detections
+        end
+
+        def allowed_unannotated?(detections)
+          return false if detections.size > max_unannotated_placeholders_allowed
+
+          detections.all? { |detected_style,| detected_style == :unannotated }
+        end
+
+        def max_unannotated_placeholders_allowed
+          cop_config['MaxUnannotatedPlaceholdersAllowed']
+        end
       end
     end
   end

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

@@ -144,25 +144,22 @@ module RuboCop
       #   # good
       #   Array 1
       class MethodCallWithArgsParentheses < Base
+        require_relative 'method_call_with_args_parentheses/omit_parentheses'
+        require_relative 'method_call_with_args_parentheses/require_parentheses'
+
         include ConfigurableEnforcedStyle
         include IgnoredMethods
         include IgnoredPattern
+        include RequireParentheses
+        include OmitParentheses
         extend AutoCorrector
 
-        def initialize(*)
-          super
-          return unless style_configured?
-
-          case style
-          when :require_parentheses
-            extend RequireParentheses
-          when :omit_parentheses
-            extend OmitParentheses
-          end
+        def on_send(node)
+          send(style, node) # call require_parentheses or omit_parentheses
         end
-
-        # @abstract Overridden in style modules
-        def autocorrect(_node); end
+        alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
 
         private
 

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -7,15 +7,19 @@ module RuboCop
         # Style omit_parentheses
         module OmitParentheses
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+          OMIT_MSG = 'Omit parentheses for method calls with arguments.'
+          private_constant :OMIT_MSG
 
-          def on_send(node)
+          private
+
+          def omit_parentheses(node)
             return unless node.parenthesized?
             return if node.implicit_call?
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
 
-            add_offense(offense_range(node)) do |corrector|
+            add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
               if parentheses_at_the_end_of_multiline_call?(node)
                 corrector.replace(args_begin(node), ' \\')
               else
@@ -24,20 +28,11 @@ module RuboCop
               corrector.remove(node.loc.end)
             end
           end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          private
 
           def offense_range(node)
             node.loc.begin.join(node.loc.end)
           end
 
-          def message(_range = nil)
-            'Omit parentheses for method calls with arguments.'
-          end
-
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -6,27 +6,23 @@ module RuboCop
       class MethodCallWithArgsParentheses
         # Style require_parentheses
         module RequireParentheses
-          def on_send(node)
+          REQUIRE_MSG = 'Use parentheses for method calls with arguments.'
+          private_constant :REQUIRE_MSG
+
+          private
+
+          def require_parentheses(node)
             return if ignored_method?(node.method_name)
             return if matches_ignored_pattern?(node.method_name)
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
 
-            add_offense(node) do |corrector|
+            add_offense(node, message: REQUIRE_MSG) do |corrector|
               corrector.replace(args_begin(node), '(')
 
               corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
             end
           end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          def message(_node = nil)
-            'Use parentheses for method calls with arguments.'
-          end
-
-          private
 
           def eligible_for_parentheses_omission?(node)
             node.operator_method? || node.setter_method? || ignored_macro?(node)

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

@@ -104,9 +104,13 @@ module RuboCop
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
 
+          return offense(begin_node, 'an interpolated expression') if interpolation?(begin_node)
+
           check_send(begin_node, node) if node.call_type?
         end
 
+        def_node_matcher :interpolation?, '[^begin ^^dstr]'
+
         def check_send(begin_node, node)
           return check_unary(begin_node, node) if node.unary_operation?
 

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

@@ -129,6 +129,9 @@ module RuboCop
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
             @local_variables_scopes[node].include?(node.method_name) ||
+            node.each_ancestor.any? do |ancestor|
+              @local_variables_scopes[ancestor].include?(node.method_name)
+            end ||
             KERNEL_METHODS.include?(node.method_name)
         end
 

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

@@ -142,10 +142,22 @@ module RuboCop
         end
 
         def comments(node)
-          processed_source.each_comment_in_lines(
-            node.loc.first_line...
-            node.loc.last_line
-          ).to_a
+          relevant_comment_ranges(node).each.with_object([]) do |range, comments|
+            comments.concat(processed_source.each_comment_in_lines(range).to_a)
+          end
+        end
+
+        def relevant_comment_ranges(node)
+          # Get source lines ranges inside the if node that aren't inside an inner node
+          # Comments inside an inner node should remain attached to that node, and not
+          # moved.
+          begin_pos = node.loc.first_line
+          end_pos = node.loc.last_line
+
+          node.child_nodes.each.with_object([]) do |child, ranges|
+            ranges << (begin_pos...child.loc.first_line)
+            begin_pos = child.loc.last_line
+          end << (begin_pos...end_pos)
         end
 
         def allowed_if_condition?(node)

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

@@ -33,6 +33,10 @@ module RuboCop
           }
         PATTERN
 
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
         def on_send(node)
           return unless string_concatenation?(node)
 
@@ -42,8 +46,12 @@ module RuboCop
           collect_parts(topmost_plus_node, parts)
 
           add_offense(topmost_plus_node) do |corrector|
-            if parts.none? { |part| uncorrectable?(part) }
+            correctable_parts = parts.none? { |part| uncorrectable?(part) }
+            if correctable_parts && !corrected_ancestor?(topmost_plus_node)
               corrector.replace(topmost_plus_node, replacement(parts))
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(topmost_plus_node)
             end
           end
         end
@@ -80,6 +88,10 @@ module RuboCop
             part.each_descendant(:block).any?
         end
 
+        def corrected_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
         def replacement(parts)
           interpolated_parts =
             parts.map do |part|

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

@@ -36,6 +36,8 @@ module RuboCop
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
               'Prefer `%<code>s`.'
         UNDERSCORE = '_'
+        DISALLOW = %i[lvasgn splat].freeze
+        private_constant :DISALLOW
 
         def on_masgn(node)
           ranges = unneeded_ranges(node)
@@ -64,7 +66,7 @@ module RuboCop
 
         def find_first_possible_offense(variables)
           variables.reduce(nil) do |offense, variable|
-            break offense unless %i[lvasgn splat].include?(variable.type)
+            break offense unless DISALLOW.include?(variable.type)
 
             var, = *variable
             var, = *var

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def total_offense_count(offense_counts)
-        offense_counts.values.inject(0, :+)
+        offense_counts.values.sum
       end
     end
   end

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -55,7 +55,7 @@ module RuboCop
       end
 
       def total_offense_count(offense_counts)
-        offense_counts.values.inject(0, :+)
+        offense_counts.values.sum
       end
     end
   end

data/lib/rubocop/options.rb

@@ -242,6 +242,9 @@ module RuboCop
   # @api private
   class OptionsValidator
     class << self
+      SYNTAX_DEPARTMENTS = %w[Syntax Lint/Syntax].freeze
+      private_constant :SYNTAX_DEPARTMENTS
+
       # Cop name validation must be done later than option parsing, so it's not
       # called from within Options.
       def validate_cop_list(names)
@@ -253,7 +256,7 @@ module RuboCop
         names.each do |name|
           next if cop_names.include?(name)
           next if departments.include?(name)
-          next if %w[Syntax Lint/Syntax].include?(name)
+          next if SYNTAX_DEPARTMENTS.include?(name)
 
           raise IncorrectCopNameError, format_message_from(name, cop_names)
         end

data/lib/rubocop/version.rb

@@ -3,24 +3,74 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.93.1'
+    STRING = '1.0.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, '\
           'rubocop-ast %<rubocop_ast_version>s, ' \
           'running on %<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'
 
+    CANONICAL_FEATURE_NAMES = { 'Rspec' => 'RSpec' }.freeze
+
     # @api private
-    def self.version(debug: false)
+    def self.version(debug: false, env: nil)
       if debug
-        format(MSG, version: STRING, parser_version: Parser::VERSION,
-                    rubocop_ast_version: RuboCop::AST::Version::STRING,
-                    ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
-                    ruby_platform: RUBY_PLATFORM)
+        verbose_version = format(MSG, version: STRING, parser_version: Parser::VERSION,
+                                      rubocop_ast_version: RuboCop::AST::Version::STRING,
+                                      ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
+                                      ruby_platform: RUBY_PLATFORM)
+        return verbose_version unless env
+
+        extension_versions = extension_versions(env)
+        return verbose_version if extension_versions.empty?
+
+        <<~VERSIONS
+          #{verbose_version}
+          #{extension_versions.join("\n")}
+        VERSIONS
       else
         STRING
       end
     end
 
+    # @api private
+    def self.extension_versions(env)
+      env.config_store.for_pwd.loaded_features.sort.map do |loaded_feature|
+        next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))
+
+        feature = match[:feature]
+        begin
+          require "rubocop/#{feature}/version"
+        rescue LoadError
+          # Not worth mentioning libs that are not installed
+        else
+          next unless (feature_version = feature_version(feature))
+
+          "  - #{loaded_feature} #{feature_version}"
+        end
+      end.compact
+    end
+
+    # Returns feature version in one of two ways:
+    #
+    # * Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
+    # * Find by `bundle gem` version style (e.g. rubocop-rake)
+    #
+    # @api private
+    def self.feature_version(feature)
+      capitalized_feature = feature.capitalize
+      extension_name = CANONICAL_FEATURE_NAMES.fetch(capitalized_feature, capitalized_feature)
+
+      # Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
+      RuboCop.const_get(extension_name)::Version::STRING
+    rescue NameError
+      begin
+        # Find by `bundle gem` version style (e.g. rubocop-rake, rubocop-packaging)
+        RuboCop.const_get(extension_name)::VERSION
+      rescue NameError
+        # noop
+      end
+    end
+
     # @api private
     def self.document_version
       STRING.match('\d+\.\d+').to_s