rbhint 0.8.5.rc1

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for numeric comparisons that can be replaced
+      # by a predicate method, such as receiver.length == 0,
+      # receiver.length > 0, receiver.length != 0,
+      # receiver.length < 1 and receiver.size == 0 that can be
+      # replaced by receiver.empty? and !receiver.empty?.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].length == 0
+      #   0 == "foobar".length
+      #   array.length < 1
+      #   {a: 1, b: 2}.length != 0
+      #   string.length > 0
+      #   hash.size > 0
+      #
+      #   # good
+      #   [1, 2, 3].empty?
+      #   "foobar".empty?
+      #   array.empty?
+      #   !{a: 1, b: 2}.empty?
+      #   !string.empty?
+      #   !hash.empty?
+      class ZeroLengthPredicate < Cop
+        ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
+        NONZERO_MSG = 'Use `!empty?` instead of ' \
+                      '`%<lhs>s %<opr>s %<rhs>s`.'
+
+        def on_send(node)
+          check_zero_length_predicate(node)
+          check_nonzero_length_predicate(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, replacement(node))
+          end
+        end
+
+        private
+
+        def check_zero_length_predicate(node)
+          zero_length_predicate = zero_length_predicate(node)
+
+          return unless zero_length_predicate
+
+          lhs, opr, rhs = zero_length_predicate
+
+          return if non_polymorphic_collection?(node)
+
+          add_offense(
+            node,
+            message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          )
+        end
+
+        def check_nonzero_length_predicate(node)
+          nonzero_length_predicate = nonzero_length_predicate(node)
+
+          return unless nonzero_length_predicate
+
+          lhs, opr, rhs = nonzero_length_predicate
+
+          return if non_polymorphic_collection?(node)
+
+          add_offense(
+            node,
+            message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          )
+        end
+
+        def_node_matcher :zero_length_predicate, <<~PATTERN
+          {(send (send (...) ${:length :size}) $:== (int $0))
+           (send (int $0) $:== (send (...) ${:length :size}))
+           (send (send (...) ${:length :size}) $:<  (int $1))
+           (send (int $1) $:> (send (...) ${:length :size}))}
+        PATTERN
+
+        def_node_matcher :nonzero_length_predicate, <<~PATTERN
+          {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
+           (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
+        PATTERN
+
+        def replacement(node)
+          receiver = zero_length_receiver(node)
+          return "#{receiver.source}.empty?" if receiver
+
+          "!#{other_receiver(node).source}.empty?"
+        end
+
+        def_node_matcher :zero_length_receiver, <<~PATTERN
+          {(send (send $_ _) :== (int 0))
+           (send (int 0) :== (send $_ _))
+           (send (send $_ _) :<  (int 1))
+           (send (int 1) :> (send $_ _))}
+        PATTERN
+
+        def_node_matcher :other_receiver, <<~PATTERN
+          {(send (send $_ _) _ _)
+           (send _ _ (send $_ _))}
+        PATTERN
+
+        # Some collection like objects in the Ruby standard library
+        # implement `#size`, but not `#empty`. We ignore those to
+        # reduce false positives.
+        def_node_matcher :non_polymorphic_collection?, <<~PATTERN
+          {(send (send (send (const nil? :File) :stat _) ...) ...)
+           (send (send (send (const nil? {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/team.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A group of cops, ready to be called on duty to inspect files.
+    # Team is responsible for selecting only relevant cops to be sent on duty,
+    # as well as insuring that the needed forces are sent along with them.
+    #
+    # For performance reasons, Team will first dispatch cops & forces in two groups,
+    # first the ones needed for autocorrection (if any), then the rest
+    # (unless autocorrections happened).
+    class Team
+      DEFAULT_OPTIONS = {
+        auto_correct: false,
+        debug: false
+      }.freeze
+
+      Investigation = Struct.new(:offenses, :errors)
+
+      attr_reader :errors, :warnings, :updated_source_file, :cops
+
+      alias updated_source_file? updated_source_file
+
+      def initialize(cops, config = nil, options = nil)
+        @cops = cops
+        @config = config
+        @options = options || DEFAULT_OPTIONS
+        @errors = []
+        @warnings = []
+
+        validate_config
+      end
+
+      # @return [Team]
+      def self.new(cop_or_classes, config, options = {})
+        # Support v0 api:
+        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
+
+        super
+      end
+
+      # @return [Team] with cops assembled from the given `cop_classes`
+      def self.mobilize(cop_classes, config, options = nil)
+        options ||= DEFAULT_OPTIONS
+        cops = mobilize_cops(cop_classes, config, options)
+        new(cops, config, options)
+      end
+
+      # @return [Array<Cop::Cop>]
+      def self.mobilize_cops(cop_classes, config, options = nil)
+        options ||= DEFAULT_OPTIONS
+        only = options.fetch(:only, [])
+        safe = options.fetch(:safe, false)
+        cop_classes.enabled(config, only, safe).map do |cop_class|
+          cop_class.new(config, options)
+        end
+      end
+
+      def autocorrect?
+        @options[:auto_correct]
+      end
+
+      def debug?
+        @options[:debug]
+      end
+
+      def inspect_file(processed_source)
+        # If we got any syntax errors, return only the syntax offenses.
+        unless processed_source.valid_syntax?
+          return Lint::Syntax.offenses_from_processed_source(
+            processed_source, @config, @options
+          )
+        end
+
+        offenses(processed_source)
+      end
+
+      def forces
+        @forces ||= forces_for(cops)
+      end
+
+      def forces_for(cops)
+        Force.all.each_with_object([]) do |force_class, forces|
+          joining_cops = cops.select { |cop| cop.join_force?(force_class) }
+          next if joining_cops.empty?
+
+          forces << force_class.new(joining_cops)
+        end
+      end
+
+      def autocorrect(buffer, cops)
+        @updated_source_file = false
+        return unless autocorrect?
+
+        new_source = autocorrect_all_cops(buffer, cops)
+
+        return if new_source == buffer.source
+
+        if @options[:stdin]
+          # holds source read in from stdin, when --stdin option is used
+          @options[:stdin] = new_source
+        else
+          filename = buffer.name
+          File.open(filename, 'w') { |f| f.write(new_source) }
+        end
+        @updated_source_file = true
+      rescue RuboCop::ErrorWithAnalyzedFileLocation => e
+        process_errors(buffer.name, [e])
+        raise e.cause
+      end
+
+      def external_dependency_checksum
+        keys = cops.map(&:external_dependency_checksum).compact
+        Digest::SHA1.hexdigest(keys.join)
+      end
+
+      private
+
+      def offenses(processed_source) # rubocop:disable Metrics/AbcSize
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run auto-correcting cops by themselves, and only
+        # run the other cops when no corrections are left
+        on_duty = roundup_relevant_cops(processed_source.file_path)
+
+        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+
+        autocorrect = investigate(autocorrect_cops, processed_source)
+
+        if autocorrect(processed_source.buffer, autocorrect_cops)
+          # We corrected some errors. Another round of inspection will be
+          # done, and any other offenses will be caught then, so we don't
+          # need to continue.
+          return autocorrect.offenses
+        end
+
+        other = investigate(other_cops, processed_source)
+
+        errors = [*autocorrect.errors, *other.errors]
+        process_errors(processed_source.path, errors)
+
+        autocorrect.offenses.concat(other.offenses)
+      end
+
+      def investigate(cops, processed_source)
+        return Investigation.new([], {}) if cops.empty?
+
+        commissioner = Commissioner.new(cops, forces_for(cops), @options)
+        offenses = commissioner.investigate(processed_source)
+
+        Investigation.new(offenses, commissioner.errors)
+      end
+
+      def roundup_relevant_cops(filename)
+        cops.reject do |cop|
+          cop.excluded_file?(filename) ||
+            !support_target_ruby_version?(cop) ||
+            !support_target_rails_version?(cop)
+        end
+      end
+
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
+
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      end
+
+      def support_target_rails_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
+
+        cop.class.support_target_rails_version?(cop.target_rails_version)
+      end
+
+      def autocorrect_all_cops(buffer, cops)
+        corrector = Corrector.new(buffer)
+
+        collate_corrections(corrector, cops)
+
+        if !corrector.corrections.empty?
+          corrector.rewrite
+        else
+          buffer.source
+        end
+      end
+
+      def collate_corrections(corrector, cops)
+        skips = Set.new
+
+        cops.each do |cop|
+          next if cop.corrections.empty?
+          next if skips.include?(cop.class)
+
+          corrector.corrections.concat(cop.corrections)
+          skips.merge(cop.class.autocorrect_incompatible_with)
+        end
+      end
+
+      def validate_config
+        cops.each do |cop|
+          cop.validate_config if cop.respond_to?(:validate_config)
+        end
+      end
+
+      def process_errors(file, errors)
+        errors.each do |error|
+          line = ":#{error.line}" if error.line
+          column = ":#{error.column}" if error.column
+          location = "#{file}#{line}#{column}"
+          cause = error.cause
+
+          if cause.is_a?(Warning)
+            handle_warning(cause, location)
+          else
+            handle_error(cause, location, error.cop)
+          end
+        end
+      end
+
+      def handle_warning(error, location)
+        message = Rainbow("#{error.message} (from file: #{location})").yellow
+
+        @warnings << message
+        warn message
+        puts error.backtrace if debug?
+      end
+
+      def handle_error(error, location, cop)
+        message = Rainbow("An error occurred while #{cop.name}" \
+                           " cop was inspecting #{location}.").red
+        @errors << message
+        warn message
+        if debug?
+          puts error.message, error.backtrace
+        else
+          warn 'To see the complete backtrace run rubocop -d.'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/util.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module contains a collection of useful utility methods.
+    module Util
+      include PathUtil
+
+      # Match literal regex characters, not including anchors, character
+      # classes, alternatives, groups, repetitions, references, etc
+      LITERAL_REGEX =
+        %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
+
+      module_function
+
+      def comment_line?(line_source)
+        line_source =~ /^\s*#/
+      end
+
+      def comment_lines?(node)
+        processed_source[line_range(node)].any? { |line| comment_line?(line) }
+      end
+
+      def line_range(node)
+        node.first_line..node.last_line
+      end
+
+      def parentheses?(node)
+        node.loc.respond_to?(:end) && node.loc.end &&
+          node.loc.end.is?(')')
+      end
+
+      def add_parentheses(node, corrector)
+        if node.arguments.empty?
+          corrector.insert_after(node, '()')
+        else
+          corrector.replace(args_begin(node), '(')
+          corrector.insert_after(args_end(node), ')')
+        end
+      end
+
+      def args_begin(node)
+        loc = node.loc
+        selector =
+          node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+        selector.end.resize(1)
+      end
+
+      def args_end(node)
+        node.loc.expression.end
+      end
+
+      def on_node(syms, sexp, excludes = [], &block)
+        return to_enum(:on_node, syms, sexp, excludes) unless block_given?
+
+        yield sexp if Array(syms).include?(sexp.type)
+        return if Array(excludes).include?(sexp.type)
+
+        sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
+      end
+
+      def begins_its_line?(range)
+        (range.source_line =~ /\S/) == range.column
+      end
+
+      # Returns, for example, a bare `if` node if the given node is an `if`
+      # with calls chained to the end of it.
+      def first_part_of_call_chain(node)
+        while node
+          case node.type
+          when :send
+            node = node.receiver
+          when :block
+            node = node.send_node
+          else
+            break
+          end
+        end
+        node
+      end
+
+      # If converting a string to Ruby string literal source code, must
+      # double quotes be used?
+      def double_quotes_required?(string)
+        # Double quotes are required for strings which either:
+        # - Contain single quotes
+        # - Contain non-printable characters, which must use an escape
+
+        # Regex matches IF there is a ' or there is a \\ in the string that is
+        # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
+        string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
+      end
+
+      def needs_escaping?(string)
+        double_quotes_required?(escape_string(string))
+      end
+
+      def escape_string(string)
+        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
+      end
+
+      def to_string_literal(string)
+        if needs_escaping?(string) && compatible_external_encoding_for?(string)
+          string.inspect
+        else
+          "'#{string.gsub('\\') { '\\\\' }}'"
+        end
+      end
+
+      def trim_string_interporation_escape_character(str)
+        str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
+      end
+
+      def interpret_string_escapes(string)
+        StringInterpreter.interpret(string)
+      end
+
+      def same_line?(node1, node2)
+        node1.respond_to?(:loc) &&
+          node2.respond_to?(:loc) &&
+          node1.loc.line == node2.loc.line
+      end
+
+      def to_supported_styles(enforced_style)
+        enforced_style
+          .sub(/^Enforced/, 'Supported')
+          .sub('Style', 'Styles')
+      end
+
+      def tokens(node)
+        @tokens ||= {}
+        return @tokens[node.object_id] if @tokens[node.object_id]
+
+        source_range = node.source_range
+        begin_pos = source_range.begin_pos
+        end_pos = source_range.end_pos
+
+        @tokens[node.object_id] = processed_source.tokens.select do |token|
+          token.end_pos <= end_pos && token.begin_pos >= begin_pos
+        end
+      end
+
+      private
+
+      def compatible_external_encoding_for?(src)
+        src = src.dup if RUBY_ENGINE == 'jruby'
+        src.force_encoding(Encoding.default_external).valid_encoding?
+      end
+    end
+  end
+end