rubbycop 0.49.0

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Bundler
+      # Gems should be alphabetically sorted within groups.
+      #
+      # @example
+      #   # bad
+      #   gem 'rubbycop'
+      #   gem 'rspec'
+      #
+      #   # good
+      #   gem 'rspec'
+      #   gem 'rubbycop'
+      #
+      #   # good
+      #   gem 'rubbycop'
+      #
+      #   gem 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   gem 'rubbycop'
+      #   # For tests
+      #   gem 'rspec'
+      class OrderedGems < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Gems should be sorted in an alphabetical order within their '\
+              'section of the Gemfile. '\
+              'Gem `%s` should appear before `%s`.'.freeze
+        def investigate(processed_source)
+          return if processed_source.ast.nil?
+          gem_declarations(processed_source.ast)
+            .each_cons(2) do |previous, current|
+            next unless consecutive_lines(previous, current)
+            next unless case_insensitive_out_of_order?(
+              current.children[2].children.first.to_s,
+              previous.children[2].children.first.to_s
+            )
+            register_offense(previous, current)
+          end
+        end
+
+        def case_insensitive_out_of_order?(string_a, string_b)
+          string_a.downcase < string_b.downcase
+        end
+
+        def consecutive_lines(previous, current)
+          first_line = get_source_range(current).first_line
+          previous.source_range.last_line == first_line - 1
+        end
+
+        def register_offense(previous, current)
+          add_offense(
+            current,
+            current.source_range,
+            format(
+              MSG,
+              current.children[2].children.first,
+              previous.children[2].children.first
+            )
+          )
+        end
+
+        def autocorrect(node)
+          previous = previous_declaration(node)
+
+          current_range = declaration_with_comment(node)
+          previous_range = declaration_with_comment(previous)
+
+          lambda do |corrector|
+            swap_range(corrector, current_range, previous_range)
+          end
+        end
+
+        def declaration_with_comment(node)
+          buffer = processed_source.buffer
+          begin_pos = get_source_range(node).begin_pos
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_pos = buffer.line_range(end_line).end_pos
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def swap_range(corrector, range1, range2)
+          src1 = range1.source
+          src2 = range2.source
+          corrector.replace(range1, src2)
+          corrector.replace(range2, src1)
+        end
+
+        def previous_declaration(node)
+          declarations = gem_declarations(processed_source.ast)
+          node_index = declarations.find_index(node)
+          declarations.to_a[node_index - 1]
+        end
+
+        def get_source_range(node)
+          unless cop_config['TreatCommentsAsGroupSeparators']
+            first_comment = processed_source.ast_with_comments[node].first
+            return first_comment.loc.expression unless first_comment.nil?
+          end
+          node.source_range
+        end
+
+        def_node_search :gem_declarations, <<-PATTERN
+          (:send, nil, :gem, ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/commissioner.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Commissioner class is responsible for processing the AST and delegating
+    # work to the specified cops.
+    class Commissioner
+      include RubbyCop::AST::Traversal
+
+      CopError = Struct.new(:error, :line, :column)
+
+      attr_reader :errors
+
+      def self.callback_methods
+        Parser::Meta::NODE_TYPES.map { |type| :"on_#{type}" }
+      end
+
+      def initialize(cops, forces = [], options = {})
+        @cops = cops
+        @forces = forces
+        @options = options
+        @callbacks = {}
+
+        reset_errors
+      end
+
+      # In the dynamically generated methods below, 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`.
+      no_child_callbacks = NO_CHILD_NODES.map do |type|
+        :"on_#{type}"
+      end
+
+      callback_methods.each do |callback|
+        next unless method_defined?(callback)
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{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
+
+            #{!no_child_callbacks.include?(callback) && 'super'}
+          end
+        EOS
+      end
+
+      def investigate(processed_source)
+        reset_errors
+        remove_irrelevant_cops(processed_source.buffer.name)
+        reset_callbacks
+        prepare(processed_source)
+        invoke_custom_processing(@cops, processed_source)
+        invoke_custom_processing(@forces, processed_source)
+        walk(processed_source.ast) if processed_source.ast
+        @cops.flat_map(&:offenses)
+      end
+
+      private
+
+      def reset_errors
+        @errors = Hash.new { |hash, k| hash[k] = [] }
+      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.
+      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
+
+      def with_cop_error_handling(cop, node = nil)
+        yield
+      rescue => e
+        raise e if @options[:raise_error]
+        if node
+          line = node.loc.line
+          column = node.loc.column
+        end
+        error = CopError.new(e, line, column)
+        @errors[cop] << error
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/cop.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RubbyCop
+  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 RubbyCop::AST::Sexp
+      extend NodePattern::Macros
+      include RubbyCop::AST::Sexp
+      include Util
+      include IgnoredNode
+      include AutocorrectLogic
+
+      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.non_rails
+        registry.without_department(:Rails)
+      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
+
+      def initialize(config = nil, options = nil)
+        @config = config || Config.new
+        @options = options || { debug: false }
+
+        @offenses = []
+        @corrections = []
+        @processed_source = nil
+      end
+
+      def join_force?(_force_class)
+        false
+      end
+
+      def cop_config
+        @cop_config ||= @config.for_cop(self)
+      end
+
+      def message(_node = nil)
+        self.class::MSG
+      end
+
+      def add_offense(node, loc, message = nil, severity = nil)
+        location = find_location(node, loc)
+
+        return if duplicate_location?(location)
+
+        severity = custom_severity || severity || default_severity
+
+        message ||= message(node)
+        message = annotate(message)
+
+        status = enabled_line?(location.line) ? correct(node) : :disabled
+
+        @offenses << Offense.new(severity, location, message, name, status)
+        yield if block_given? && status != :disabled
+      end
+
+      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)
+        return :unsupported unless support_autocorrect?
+        return :uncorrected unless autocorrect?
+
+        correction = autocorrect(node)
+        return :uncorrected unless correction
+        @corrections << correction
+        :corrected
+      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)
+        RubbyCop::Cop::MessageAnnotator.new(
+          config, cop_config, @options
+        ).annotate(message, name)
+      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 unless @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