rubocop 0.75.1

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # Add a comment describing each gem in your Gemfile.
+      #
+      # @example
+      #   # bad
+      #
+      #   gem 'foo'
+      #
+      #   # good
+      #
+      #   # Helpers for the foo things.
+      #   gem 'foo'
+      #
+      class GemComment < Cop
+        include DefNode
+
+        MSG = 'Missing gem description comment.'
+
+        def_node_matcher :gem_declaration?, '(send nil? :gem str ...)'
+
+        def on_send(node)
+          return unless gem_declaration?(node)
+          return if whitelisted_gem?(node)
+          return if commented?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def commented?(node)
+          preceding_lines = preceding_lines(node)
+          preceding_comment?(node, preceding_lines.last)
+        end
+
+        # The args node1 & node2 may represent a RuboCop::AST::Node
+        # or a Parser::Source::Comment. Both respond to #loc.
+        def precede?(node1, node2)
+          node2.loc.line - node1.loc.line == 1
+        end
+
+        def preceding_lines(node)
+          processed_source.ast_with_comments[node].select do |line|
+            line.loc.line < node.loc.line
+          end
+        end
+
+        def preceding_comment?(node1, node2)
+          node1 && node2 && precede?(node2, node1) &&
+            comment_line?(node2.loc.expression.source)
+        end
+
+        def whitelisted_gem?(node)
+          whitelist = Array(cop_config['Whitelist'])
+          whitelist.include?(node.first_argument.value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # 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.
+      #
+      # 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 can not be specified was considered.
+      # Consider using HTTP only if you can not use HTTPS.
+      #
+      # @example
+      #   # bad
+      #   source :gemcutter
+      #   source :rubygems
+      #   source :rubyforge
+      #
+      #   # good
+      #   source 'https://rubygems.org' # strongly recommended
+      #   source 'http://rubygems.org'
+      class InsecureProtocolSource < Cop
+        include RangeHelp
+
+        MSG = 'The source `:%<source>s` is deprecated because HTTP requests ' \
+              'are insecure. ' \
+              "Please change your source to 'https://rubygems.org' " \
+              "if possible, or 'http://rubygems.org' if not."
+
+        def_node_matcher :insecure_protocol_source?, <<~PATTERN
+          (send nil? :source
+            (sym ${:gemcutter :rubygems :rubyforge}))
+        PATTERN
+
+        def on_send(node)
+          insecure_protocol_source?(node) do |source|
+            message = format(MSG, source: source)
+
+            add_offense(
+              node,
+              location: range(node.first_argument.loc.expression),
+              message: message
+            )
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(
+              node.first_argument.loc.expression, "'https://rubygems.org'"
+            )
+          end
+        end
+
+        private
+
+        def range(node)
+          range_between(node.begin_pos, node.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # Gems should be alphabetically sorted within groups.
+      #
+      # @example
+      #   # bad
+      #   gem 'rubocop'
+      #   gem 'rspec'
+      #
+      #   # good
+      #   gem 'rspec'
+      #   gem 'rubocop'
+      #
+      #   # good
+      #   gem 'rubocop'
+      #
+      #   gem 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   gem 'rubocop'
+      #   # For tests
+      #   gem 'rspec'
+      class OrderedGems < Cop
+        include ConfigurableEnforcedStyle
+        include OrderedGemNode
+
+        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)
+          return if processed_source.blank?
+
+          gem_declarations(processed_source.ast)
+            .each_cons(2) do |previous, current|
+            next unless consecutive_lines(previous, current)
+            next unless case_insensitive_out_of_order?(
+              gem_name(current),
+              gem_name(previous)
+            )
+
+            register_offense(previous, current)
+          end
+        end
+
+        def autocorrect(node)
+          OrderedGemCorrector.correct(
+            processed_source,
+            node,
+            previous_declaration(node),
+            treat_comments_as_separators
+          )
+        end
+
+        private
+
+        def previous_declaration(node)
+          declarations = gem_declarations(processed_source.ast)
+          node_index = declarations.map(&:location).find_index(node.location)
+          declarations.to_a[node_index - 1]
+        end
+
+        def_node_search :gem_declarations, <<~PATTERN
+          (:send nil? :gem str ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/commissioner.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Commissioner class is responsible for processing the AST and delegating
+    # work to the specified cops.
+    class Commissioner
+      include RuboCop::AST::Traversal
+
+      attr_reader :errors
+
+      def initialize(cops, forces = [], options = {})
+        @cops = cops
+        @forces = forces
+        @options = options
+        @callbacks = {}
+
+        reset_errors
+      end
+
+      # Create methods like :on_send, :on_super, etc. They will be called
+      # during AST traversal and try to call corresponding methods on cops.
+      # A call to `super` is used
+      # to continue iterating over the children of a node.
+      # However, if we know that a certain node type (like `int`) never has
+      # child nodes, there is no reason to pay the cost of calling `super`.
+      Parser::Meta::NODE_TYPES.each do |node_type|
+        method_name = :"on_#{node_type}"
+        next unless method_defined?(method_name)
+
+        define_method(method_name) do |node|
+          trigger_responding_cops(method_name, node)
+          super(node) unless NO_CHILD_NODES.include?(node_type)
+        end
+      end
+
+      def investigate(processed_source)
+        reset_errors
+        remove_irrelevant_cops(processed_source.file_path)
+        reset_callbacks
+        prepare(processed_source)
+        invoke_custom_processing(@cops, processed_source)
+        invoke_custom_processing(@forces, processed_source)
+        walk(processed_source.ast) unless processed_source.blank?
+        invoke_custom_post_walk_processing(@cops, processed_source)
+        @cops.flat_map(&:offenses)
+      end
+
+      private
+
+      def trigger_responding_cops(callback, node)
+        @callbacks[callback] ||= @cops.select do |cop|
+          cop.respond_to?(callback)
+        end
+        @callbacks[callback].each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.send(callback, node)
+          end
+        end
+      end
+
+      def reset_errors
+        @errors = []
+      end
+
+      def remove_irrelevant_cops(filename)
+        @cops.reject! { |cop| cop.excluded_file?(filename) }
+        @cops.reject! do |cop|
+          cop.class.respond_to?(:support_target_ruby_version?) &&
+            !cop.class.support_target_ruby_version?(cop.target_ruby_version)
+        end
+        @cops.reject! do |cop|
+          cop.class.respond_to?(:support_target_rails_version?) &&
+            !cop.class.support_target_rails_version?(cop.target_rails_version)
+        end
+      end
+
+      def reset_callbacks
+        @callbacks.clear
+      end
+
+      # TODO: Bad design.
+      def prepare(processed_source)
+        @cops.each { |cop| cop.processed_source = processed_source }
+      end
+
+      # There are cops/forces that require their own custom processing.
+      # If they define the #investigate method, all input parameters passed
+      # to the commissioner will be passed to the cop too in order to do
+      # its own processing.
+      #
+      # These custom processors are invoked before the AST traversal,
+      # so they can build initial state that is later used by callbacks
+      # during the AST traversal.
+      def invoke_custom_processing(cops_or_forces, processed_source)
+        cops_or_forces.each do |cop|
+          next unless cop.respond_to?(:investigate)
+
+          with_cop_error_handling(cop) do
+            cop.investigate(processed_source)
+          end
+        end
+      end
+
+      # There are cops that require their own custom processing **after**
+      # the AST traversal. By performing the walk before invoking these
+      # custom processors, we allow these cops to build their own
+      # state during the primary AST traversal instead of performing their
+      # own AST traversals. Minimizing the number of walks is more efficient.
+      #
+      # If they define the #investigate_post_walk method, all input parameters
+      # passed to the commissioner will be passed to the cop too in order to do
+      # its own processing.
+      def invoke_custom_post_walk_processing(cops, processed_source)
+        cops.each do |cop|
+          next unless cop.respond_to?(:investigate_post_walk)
+
+          with_cop_error_handling(cop) do
+            cop.investigate_post_walk(processed_source)
+          end
+        end
+      end
+
+      # Allow blind rescues here, since we're absorbing and packaging or
+      # re-raising exceptions that can be raised from within the individual
+      # cops' `#investigate` methods.
+      def with_cop_error_handling(cop, node = nil)
+        yield
+      rescue StandardError => e
+        raise e if @options[:raise_error]
+
+        err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        @errors << err
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cop.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RuboCop
+  module Cop
+    # A scaffold for concrete cops.
+    #
+    # The Cop class is meant to be extended.
+    #
+    # Cops track offenses and can autocorrect them on the fly.
+    #
+    # A commissioner object is responsible for traversing the AST and invoking
+    # the specific callbacks on each cop.
+    # If a cop needs to do its own processing of the AST or depends on
+    # something else, it should define the `#investigate` method and do
+    # the processing there.
+    #
+    # @example
+    #
+    #   class CustomCop < Cop
+    #     def investigate(processed_source)
+    #       # Do custom processing
+    #     end
+    #   end
+    class Cop
+      extend RuboCop::AST::Sexp
+      extend NodePattern::Macros
+      include RuboCop::AST::Sexp
+      include Util
+      include IgnoredNode
+      include AutocorrectLogic
+
+      Correction = Struct.new(:lambda, :node, :cop) do
+        def call(corrector)
+          lambda.call(corrector)
+        rescue StandardError => e
+          raise ErrorWithAnalyzedFileLocation.new(
+            cause: e, node: node, cop: cop
+          )
+        end
+      end
+
+      attr_reader :config, :offenses, :corrections
+      attr_accessor :processed_source # TODO: Bad design.
+
+      @registry = Registry.new
+
+      class << self
+        attr_reader :registry
+      end
+
+      def self.all
+        registry.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin)
+        registry.qualified_cop_name(name, origin)
+      end
+
+      def self.inherited(subclass)
+        registry.enlist(subclass)
+      end
+
+      def self.badge
+        @badge ||= Badge.for(name)
+      end
+
+      def self.cop_name
+        badge.to_s
+      end
+
+      def self.department
+        badge.department
+      end
+
+      def self.lint?
+        department == :Lint
+      end
+
+      # Returns true if the cop name or the cop namespace matches any of the
+      # given names.
+      def self.match?(given_names)
+        return false unless given_names
+
+        given_names.include?(cop_name) ||
+          given_names.include?(department.to_s)
+      end
+
+      # List of cops that should not try to autocorrect at the same
+      # time as this cop
+      #
+      # @return [Array<RuboCop::Cop::Cop>]
+      #
+      # @api public
+      def self.autocorrect_incompatible_with
+        []
+      end
+
+      def initialize(config = nil, options = nil)
+        @config = config || Config.new
+        @options = options || { debug: false }
+
+        @offenses = []
+        @corrections = []
+        @corrected_nodes = {}
+        @corrected_nodes.compare_by_identity
+        @processed_source = nil
+      end
+
+      def join_force?(_force_class)
+        false
+      end
+
+      def cop_config
+        # Use department configuration as basis, but let individual cop
+        # configuration override.
+        @cop_config ||= @config.for_cop(self.class.department.to_s)
+                               .merge(@config.for_cop(self))
+      end
+
+      def message(_node = nil)
+        self.class::MSG
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_offense(node, location: :expression, message: nil, severity: nil)
+        loc = find_location(node, location)
+
+        return if duplicate_location?(loc)
+
+        severity = custom_severity || severity || default_severity
+
+        message ||= message(node)
+        message = annotate(message)
+
+        status = enabled_line?(loc.line) ? correct(node) : :disabled
+
+        @offenses << Offense.new(severity, loc, message, name, status)
+        yield if block_given? && status != :disabled
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def find_location(node, loc)
+        # Location can be provided as a symbol, e.g.: `:keyword`
+        loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
+      end
+
+      def duplicate_location?(location)
+        @offenses.any? { |o| o.location == location }
+      end
+
+      def correct(node)
+        reason = reason_to_not_correct(node)
+        return reason if reason
+
+        @corrected_nodes[node] = true
+        if support_autocorrect?
+          correction = autocorrect(node)
+          return :uncorrected unless correction
+
+          @corrections << Correction.new(correction, node, self)
+          :corrected
+        elsif disable_uncorrectable?
+          disable_uncorrectable(node)
+          :corrected_with_todo
+        end
+      end
+
+      def reason_to_not_correct(node)
+        return :unsupported unless correctable?
+        return :uncorrected unless autocorrect?
+        return :already_corrected if @corrected_nodes.key?(node)
+
+        nil
+      end
+
+      def disable_uncorrectable(node)
+        @disabled_lines ||= {}
+        line = node.location.line
+        return if @disabled_lines.key?(line)
+
+        @disabled_lines[line] = true
+        @corrections << Correction.new(disable_offense(node), node, self)
+      end
+
+      def config_to_allow_offenses
+        Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses[cop_name] ||= {}
+      end
+
+      def config_to_allow_offenses=(hash)
+        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] =
+          hash
+      end
+
+      def target_ruby_version
+        @config.target_ruby_version
+      end
+
+      def target_rails_version
+        @config.target_rails_version
+      end
+
+      def parse(source, path = nil)
+        ProcessedSource.new(source, target_ruby_version, path)
+      end
+
+      def cop_name
+        @cop_name ||= self.class.cop_name
+      end
+
+      alias name cop_name
+
+      def relevant_file?(file)
+        file_name_matches_any?(file, 'Include', true) &&
+          !file_name_matches_any?(file, 'Exclude', false)
+      end
+
+      def excluded_file?(file)
+        !relevant_file?(file)
+      end
+
+      private
+
+      def annotate(message)
+        RuboCop::Cop::MessageAnnotator.new(
+          config, cop_name, cop_config, @options
+        ).annotate(message)
+      end
+
+      def file_name_matches_any?(file, parameter, default_result)
+        patterns = cop_config[parameter]
+        return default_result unless patterns
+
+        path = nil
+        patterns.any? do |pattern|
+          # Try to match the absolute path, as Exclude properties are absolute.
+          next true if match_path?(pattern, file)
+
+          # Try with relative path.
+          path ||= config.path_relative_to_config(file)
+          match_path?(pattern, path)
+        end
+      end
+
+      def enabled_line?(line_number)
+        return true if @options[:ignore_disable_comments] || !@processed_source
+
+        @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
+      end
+
+      def default_severity
+        self.class.lint? ? :warning : :convention
+      end
+
+      def custom_severity
+        severity = cop_config['Severity']
+        return unless severity
+
+        if Severity::NAMES.include?(severity.to_sym)
+          severity.to_sym
+        else
+          message = "Warning: Invalid severity '#{severity}'. " \
+            "Valid severities are #{Severity::NAMES.join(', ')}."
+          warn(Rainbow(message).red)
+        end
+      end
+    end
+  end
+end