rubocop 1.18.0 → 1.56.0

data/lib/rubocop/cop/bundler/duplicated_group.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # A Gem group, or a set of groups, should be listed only once in a Gemfile.
+      #
+      # @example
+      #   # bad
+      #   group :development do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :development do
+      #     gem 'rubocop-rails'
+      #   end
+      #
+      #   # bad (same set of groups declared twice)
+      #   group :development, :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :test, :development do
+      #     gem 'rspec'
+      #   end
+      #
+      #   # good
+      #   group :development do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :development, :test do
+      #     gem 'rspec'
+      #   end
+      #
+      #   # good
+      #   gem 'rubocop', groups: [:development, :test]
+      #   gem 'rspec', groups: [:development, :test]
+      #
+      class DuplicatedGroup < Base
+        include RangeHelp
+
+        MSG = 'Gem group `%<group_name>s` already defined on line ' \
+              '%<line_of_first_occurrence>d of the Gemfile.'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          duplicated_group_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              register_offense(node, node.arguments.map(&:value).join(', '), nodes.first.first_line)
+            end
+          end
+        end
+
+        private
+
+        # @!method group_declarations(node)
+        def_node_search :group_declarations, '(send nil? :group ...)'
+
+        def duplicated_group_nodes
+          group_declarations(processed_source.ast)
+            .group_by { |node| node.arguments.map(&:value).map(&:to_s).sort }
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
+        def register_offense(node, group_name, line_of_first_occurrence)
+          line_range = node.loc.column...node.loc.last_column
+          offense_location = source_range(processed_source.buffer, node.first_line, line_range)
+          message = format(
+            MSG,
+            group_name: group_name,
+            line_of_first_occurrence: line_of_first_occurrence
+          )
+          add_offense(offense_location, message: message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -88,7 +88,7 @@ module RuboCop
         CHECKED_OPTIONS_CONFIG = 'OnlyFor'
         VERSION_SPECIFIERS_OPTION = 'version_specifiers'
         RESTRICTIVE_VERSION_SPECIFIERS_OPTION = 'restrictive_version_specifiers'
-        RESTRICTIVE_VERSION_PATTERN = /<|~>/.freeze
+        RESTRICTIVE_VERSION_PATTERN = /\A\s*(?:<|~>|\d|=)/.freeze
         RESTRICT_ON_SEND = %i[gem].freeze
 
         def on_send(node)
@@ -124,7 +124,7 @@ module RuboCop
         end
 
         def preceding_comment?(node1, node2)
-          node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
+          node1 && node2 && precede?(node2, node1) && comment_line?(node2.source)
         end
 
         def ignored_gem?(node)
@@ -150,10 +150,10 @@ module RuboCop
         # Version specifications that restrict all updates going forward. This excludes versions
         # like ">= 1.0" or "!= 2.0.3".
         def restrictive_version_specified_gem?(node)
-          return unless version_specified_gem?(node)
+          return false unless version_specified_gem?(node)
 
-          node.arguments
-              .any? { |arg| arg&.str_type? && RESTRICTIVE_VERSION_PATTERN.match?(arg.to_s) }
+          node.arguments[1..]
+              .any? { |arg| arg&.str_type? && RESTRICTIVE_VERSION_PATTERN.match?(arg.value) }
         end
 
         def contains_checked_options?(node)

data/lib/rubocop/cop/bundler/gem_filename.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # Verifies that a project contains Gemfile or gems.rb file and correct
+      # associated lock file based on the configuration.
+      #
+      # @example EnforcedStyle: Gemfile (default)
+      #   # bad
+      #   Project contains gems.rb and gems.locked files
+      #
+      #   # bad
+      #   Project contains Gemfile and gems.locked file
+      #
+      #   # good
+      #   Project contains Gemfile and Gemfile.lock
+      #
+      # @example EnforcedStyle: gems.rb
+      #   # bad
+      #   Project contains Gemfile and Gemfile.lock files
+      #
+      #   # bad
+      #   Project contains gems.rb and Gemfile.lock file
+      #
+      #   # good
+      #   Project contains gems.rb and gems.locked files
+      class GemFilename < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_GEMFILE_REQUIRED = '`gems.rb` file was found but `Gemfile` is required ' \
+                               '(file path: %<file_path>s).'
+        MSG_GEMS_RB_REQUIRED = '`Gemfile` was found but `gems.rb` file is required ' \
+                               '(file path: %<file_path>s).'
+        MSG_GEMFILE_MISMATCHED = 'Expected a `Gemfile.lock` with `Gemfile` but found ' \
+                                 '`gems.locked` file (file path: %<file_path>s).'
+        MSG_GEMS_RB_MISMATCHED = 'Expected a `gems.locked` file with `gems.rb` but found ' \
+                                 '`Gemfile.lock` (file path: %<file_path>s).'
+        GEMFILE_FILES = %w[Gemfile Gemfile.lock].freeze
+        GEMS_RB_FILES = %w[gems.rb gems.locked].freeze
+
+        def on_new_investigation
+          file_path = processed_source.file_path
+          basename = File.basename(file_path)
+          return if expected_gemfile?(basename)
+
+          register_offense(file_path, basename)
+        end
+
+        private
+
+        def register_offense(file_path, basename)
+          register_gemfile_offense(file_path, basename) if gemfile_offense?(basename)
+          register_gems_rb_offense(file_path, basename) if gems_rb_offense?(basename)
+        end
+
+        def register_gemfile_offense(file_path, basename)
+          message = case basename
+                    when 'gems.rb'
+                      MSG_GEMFILE_REQUIRED
+                    when 'gems.locked'
+                      MSG_GEMFILE_MISMATCHED
+                    end
+
+          add_global_offense(format(message, file_path: file_path))
+        end
+
+        def register_gems_rb_offense(file_path, basename)
+          message = case basename
+                    when 'Gemfile'
+                      MSG_GEMS_RB_REQUIRED
+                    when 'Gemfile.lock'
+                      MSG_GEMS_RB_MISMATCHED
+                    end
+
+          add_global_offense(format(message, file_path: file_path))
+        end
+
+        def gemfile_offense?(basename)
+          gemfile_required? && GEMS_RB_FILES.include?(basename)
+        end
+
+        def gems_rb_offense?(basename)
+          gems_rb_required? && GEMFILE_FILES.include?(basename)
+        end
+
+        def expected_gemfile?(basename)
+          (gemfile_required? && GEMFILE_FILES.include?(basename)) ||
+            (gems_rb_required? && GEMS_RB_FILES.include?(basename))
+        end
+
+        def gemfile_required?
+          style == :Gemfile
+        end
+
+        def gems_rb_required?
+          style == :'gems.rb'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/bundler/gem_version.rb

@@ -105,13 +105,13 @@ module RuboCop
         end
 
         def required_offense?(node)
-          return unless required_style?
+          return false unless required_style?
 
           !includes_version_specification?(node) && !includes_commit_reference?(node)
         end
 
         def forbidden_offense?(node)
-          return unless forbidden_style?
+          return false unless forbidden_style?
 
           includes_version_specification?(node) || includes_commit_reference?(node)
         end

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -3,18 +3,21 @@
 module RuboCop
   module Cop
     module Bundler
-      # The symbol argument `:gemcutter`, `:rubygems`, and `:rubyforge`
-      # are deprecated. So please change your source to URL string that
-      # 'https://rubygems.org' if possible, or 'http://rubygems.org' if not.
+      # Passing symbol arguments to `source` (e.g. `source :rubygems`) is
+      # deprecated because they default to using HTTP requests. Instead, specify
+      # `'https://rubygems.org'` if possible, or `'http://rubygems.org'` if not.
       #
-      # This autocorrect will replace these symbols with 'https://rubygems.org'.
-      # Because it is secure, HTTPS request is strongly recommended. And in
-      # most use cases HTTPS will be fine.
+      # When autocorrecting, this cop will replace symbol arguments with
+      # `'https://rubygems.org'`.
       #
-      # However, it don't replace all `sources` of `http://` with `https://`.
-      # For example, when specifying an internal gem server using HTTP on the
-      # intranet, a use case where HTTPS cannot be specified was considered.
-      # Consider using HTTP only if you cannot use HTTPS.
+      # This cop will not replace existing sources that use `http://`. This may
+      # be necessary where HTTPS is not available. For example, where using an
+      # internal gem server via an intranet, or where HTTPS is prohibited.
+      # However, you should strongly prefer `https://` where possible, as it is
+      # more secure.
+      #
+      # If you don't allow `http://`, please set `false` to `AllowHttpProtocol`.
+      # This option is `true` by default for safe autocorrection.
       #
       # @example
       #   # bad
@@ -24,7 +27,17 @@ module RuboCop
       #
       #   # good
       #   source 'https://rubygems.org' # strongly recommended
+      #
+      # @example AllowHttpProtocol: true (default)
+      #
+      #   # good
+      #   source 'http://rubygems.org' # use only if HTTPS is unavailable
+      #
+      # @example AllowHttpProtocol: false
+      #
+      #   # bad
       #   source 'http://rubygems.org'
+      #
       class InsecureProtocolSource < Base
         include RangeHelp
         extend AutoCorrector
@@ -33,29 +46,40 @@ module RuboCop
               'are insecure. ' \
               "Please change your source to 'https://rubygems.org' " \
               "if possible, or 'http://rubygems.org' if not."
+        MSG_HTTP_PROTOCOL = 'Use `https://rubygems.org` instead of `http://rubygems.org`.'
 
         RESTRICT_ON_SEND = %i[source].freeze
 
         # @!method insecure_protocol_source?(node)
         def_node_matcher :insecure_protocol_source?, <<~PATTERN
           (send nil? :source
-            $(sym ${:gemcutter :rubygems :rubyforge}))
+            ${(sym :gemcutter) (sym :rubygems) (sym :rubyforge) (:str "http://rubygems.org")})
         PATTERN
 
         def on_send(node)
-          insecure_protocol_source?(node) do |source_node, source|
-            message = format(MSG, source: source)
-
-            add_offense(
-              source_node,
-              message: message
-            ) do |corrector|
-              corrector.replace(
-                source_node, "'https://rubygems.org'"
-              )
+          insecure_protocol_source?(node) do |source_node|
+            source = source_node.value
+            use_http_protocol = source == 'http://rubygems.org'
+
+            return if allow_http_protocol? && use_http_protocol
+
+            message = if use_http_protocol
+                        MSG_HTTP_PROTOCOL
+                      else
+                        format(MSG, source: source)
+                      end
+
+            add_offense(source_node, message: message) do |corrector|
+              corrector.replace(source_node, "'https://rubygems.org'")
             end
           end
         end
+
+        private
+
+        def allow_http_protocol?
+          cop_config.fetch('AllowHttpProtocol', true)
+        end
       end
     end
   end

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -19,20 +19,28 @@ module RuboCop
       #
       #   gem 'rspec'
       #
-      #   # good only if TreatCommentsAsGroupSeparators is true
+      # @example TreatCommentsAsGroupSeparators: true (default)
+      #   # good
       #   # For code quality
       #   gem 'rubocop'
       #   # For tests
       #   gem 'rspec'
-      class OrderedGems < Cop
-        include ConfigurableEnforcedStyle
+      #
+      # @example TreatCommentsAsGroupSeparators: false
+      #   # bad
+      #   # For code quality
+      #   gem 'rubocop'
+      #   # For tests
+      #   gem 'rspec'
+      class OrderedGems < Base
+        extend AutoCorrector
         include OrderedGemNode
 
-        MSG = 'Gems should be sorted in an alphabetical order within their '\
-              'section of the Gemfile. '\
+        MSG = 'Gems should be sorted in an alphabetical order within their ' \
+              'section of the Gemfile. ' \
               'Gem `%<previous>s` should appear before `%<current>s`.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
           gem_declarations(processed_source.ast)
@@ -44,15 +52,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          OrderedGemCorrector.correct(
-            processed_source,
-            node,
-            previous_declaration(node),
-            treat_comments_as_separators
-          )
-        end
-
         private
 
         def previous_declaration(node)

data/lib/rubocop/cop/commissioner.rb

@@ -76,13 +76,14 @@ module RuboCop
       end
 
       # @return [InvestigationReport]
-      def investigate(processed_source)
+      def investigate(processed_source, offset: 0, original: processed_source)
         reset
 
-        @cops.each { |cop| cop.send :begin_investigation, processed_source }
+        begin_investigation(processed_source, offset: offset, original: original)
         if processed_source.valid_syntax?
           invoke(:on_new_investigation, @cops)
-          invoke(:investigate, @forces, processed_source)
+          invoke_with_argument(:investigate, @forces, processed_source)
+
           walk(processed_source.ast) unless @cops.empty?
           invoke(:on_investigation_end, @cops)
         else
@@ -94,6 +95,12 @@ module RuboCop
 
       private
 
+      def begin_investigation(processed_source, offset:, original:)
+        @cops.each do |cop|
+          cop.begin_investigation(processed_source, offset: offset, original: original)
+        end
+      end
+
       def trigger_responding_cops(callback, node)
         @callbacks[callback]&.each do |cop|
           with_cop_error_handling(cop, node) do
@@ -149,8 +156,12 @@ module RuboCop
         map
       end
 
-      def invoke(callback, cops, *args)
-        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, *args) } }
+      def invoke(callback, cops)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
+      end
+
+      def invoke_with_argument(callback, cops, arg)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, arg) } }
       end
 
       # Allow blind rescues here, since we're absorbing and packaging or
@@ -159,9 +170,11 @@ module RuboCop
       def with_cop_error_handling(cop, node = nil)
         yield
       rescue StandardError => e
-        raise e if @options[:raise_error]
+        raise e if @options[:raise_error] # For internal testing
 
         err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        raise err if @options[:raise_cop_error] # From user-input option
+
         @errors << err
       end
     end

data/lib/rubocop/cop/cop.rb

@@ -7,7 +7,7 @@ module RuboCop
   module Cop
     # @deprecated Use Cop::Base instead
     # Legacy scaffold for Cops.
-    # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+    # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
     class Cop < Base
       attr_reader :offenses
 
@@ -22,9 +22,42 @@ module RuboCop
         end
       end
 
+      def self.support_autocorrect?
+        method_defined?(:autocorrect)
+      end
+
+      def self.joining_forces
+        return unless method_defined?(:join_force?)
+
+        cop = new
+        Force.all.select { |force_class| cop.join_force?(force_class) }
+      end
+
+      ### Deprecated registry access
+
+      # @deprecated Use Registry.global
+      def self.registry
+        Registry.global
+      end
+
+      # @deprecated Use Registry.all
+      def self.all
+        Registry.all
+      end
+
+      # @deprecated Use Registry.qualified_cop_name
+      def self.qualified_cop_name(name, origin)
+        Registry.qualified_cop_name(name, origin)
+      end
+
       def add_offense(node_or_range, location: :expression, message: nil, severity: nil, &block)
         @v0_argument = node_or_range
         range = find_location(node_or_range, location)
+
+        # Since this range may be generated from Ruby code embedded in some
+        # template file, we convert it to location info in the original file.
+        range = range_for_original(range)
+
         if block.nil? && !support_autocorrect?
           super(range, message: message, severity: severity)
         else
@@ -45,17 +78,6 @@ module RuboCop
         self.class.support_autocorrect?
       end
 
-      def self.support_autocorrect?
-        method_defined?(:autocorrect)
-      end
-
-      def self.joining_forces
-        return unless method_defined?(:join_force?)
-
-        cop = new
-        Force.all.select { |force_class| cop.join_force?(force_class) }
-      end
-
       # @deprecated
       def corrections
         # warn 'Cop#corrections is deprecated' TODO
@@ -76,31 +98,21 @@ module RuboCop
         super
       end
 
-      ### Deprecated registry access
-
-      # @deprecated Use Registry.global
-      def self.registry
-        Registry.global
-      end
-
-      # @deprecated Use Registry.all
-      def self.all
-        Registry.all
-      end
+      # Called before any investigation
+      # @api private
+      def begin_investigation(processed_source, offset: 0, original: processed_source)
+        super
+        @offenses = current_offenses
+        @last_corrector = @current_corrector
 
-      # @deprecated Use Registry.qualified_cop_name
-      def self.qualified_cop_name(name, origin)
-        Registry.qualified_cop_name(name, origin)
+        # We need to keep track of the original source and offset,
+        # because `processed_source` here may be an embedded code in it.
+        @current_offset = offset
+        @current_original = original
       end
 
       private
 
-      def begin_investigation(processed_source)
-        super
-        @offenses = @current_offenses
-        @last_corrector = @current_corrector
-      end
-
       # Override Base
       def callback_argument(_range)
         @v0_argument
@@ -126,10 +138,10 @@ module RuboCop
       def correction_lambda
         return unless support_autocorrect?
 
-        dedup_on_node(@v0_argument) { autocorrect(@v0_argument) }
+        dedupe_on_node(@v0_argument) { autocorrect(@v0_argument) }
       end
 
-      def dedup_on_node(node)
+      def dedupe_on_node(node)
         @corrected_nodes ||= {}.compare_by_identity
         yield unless @corrected_nodes.key?(node)
       ensure
@@ -141,6 +153,14 @@ module RuboCop
       rescue ::Parser::ClobberingError
         # ignore Clobbering errors
       end
+
+      def range_for_original(range)
+        ::Parser::Source::Range.new(
+          @current_original.buffer,
+          range.begin_pos + @current_offset,
+          range.end_pos + @current_offset
+        )
+      end
     end
   end
 end

data/lib/rubocop/cop/corrector.rb

@@ -11,6 +11,20 @@ module RuboCop
     class Corrector < ::Parser::Source::TreeRewriter
       NOOP_CONSUMER = ->(diagnostic) {} # noop
 
+      # Duck typing for get to a ::Parser::Source::Buffer
+      def self.source_buffer(source)
+        source = source.processed_source if source.respond_to?(:processed_source)
+        source = source.buffer if source.respond_to?(:buffer)
+        source = source.source_buffer if source.respond_to?(:source_buffer)
+
+        unless source.is_a? ::Parser::Source::Buffer
+          raise TypeError, 'Expected argument to lead to a Parser::Source::Buffer ' \
+                           "but got #{source.inspect}"
+        end
+
+        source
+      end
+
       # @param source [Parser::Source::Buffer, or anything
       #                leading to one via `(processed_source.)buffer`]
       #
@@ -64,18 +78,24 @@ module RuboCop
         remove(to_remove)
       end
 
-      # Duck typing for get to a ::Parser::Source::Buffer
-      def self.source_buffer(source)
-        source = source.processed_source if source.respond_to?(:processed_source)
-        source = source.buffer if source.respond_to?(:buffer)
-        source = source.source_buffer if source.respond_to?(:source_buffer)
+      # Swaps sources at the given ranges.
+      #
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range1
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range2
+      def swap(node_or_range1, node_or_range2)
+        range1 = to_range(node_or_range1)
+        range2 = to_range(node_or_range2)
 
-        unless source.is_a? ::Parser::Source::Buffer
-          raise TypeError, 'Expected argument to lead to a Parser::Source::Buffer ' \
-                           "but got #{source.inspect}"
+        if range1.end_pos == range2.begin_pos
+          insert_before(range1, range2.source)
+          remove(range2)
+        elsif range2.end_pos == range1.begin_pos
+          insert_before(range2, range1.source)
+          remove(range1)
+        else
+          replace(range1, range2.source)
+          replace(range2, range1.source)
         end
-
-        source
       end
 
       private
@@ -84,7 +104,7 @@ module RuboCop
       def to_range(node_or_range)
         range = case node_or_range
                 when ::RuboCop::AST::Node, ::Parser::Source::Comment
-                  node_or_range.loc.expression
+                  node_or_range.source_range
                 when ::Parser::Source::Range
                   node_or_range
                 else
@@ -109,8 +129,8 @@ module RuboCop
                 "Parser::Source::Buffer, but got #{buffer.class}"
         end
         raise "Correction target buffer #{buffer.object_id} " \
-              "name:#{buffer.name.inspect}" \
-              " is not current #{@source_buffer.object_id} " \
+              "name:#{buffer.name.inspect} " \
+              "is not current #{@source_buffer.object_id} " \
               "name:#{@source_buffer.name.inspect} under investigation"
       end
     end