rubbycop 0.49.0

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 `%s %s %s`.'.freeze
+        NONZERO_MSG = 'Use `!empty?` instead of `%s %s %s`.'.freeze
+
+        def on_send(node)
+          zero_length_predicate = zero_length_predicate(node)
+
+          if zero_length_predicate
+            add_offense(node, :expression,
+                        format(ZERO_MSG, *zero_length_predicate))
+          end
+
+          nonzero_length_predicate = nonzero_length_predicate(node)
+
+          # rubbycop:disable Style/GuardClause
+          if nonzero_length_predicate
+            add_offense(node, :expression,
+                        format(NONZERO_MSG, *nonzero_length_predicate))
+          end
+          # rubbycop:enable Style/GuardClause
+        end
+
+        def_node_matcher :zero_length_predicate, <<-END
+          {(send (send (...) ${:length :size}) $:== (int $0))
+           (send (int $0) $:== (send (...) ${:length :size}))
+           (send (send (...) ${:length :size}) $:<  (int $1))
+           (send (int $1) $:> (send (...) ${:length :size}))}
+        END
+
+        def_node_matcher :nonzero_length_predicate, <<-END
+          {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
+           (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
+        END
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement(node))
+          end
+        end
+
+        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, <<-END
+          {(send (send $_ _) :== (int 0))
+           (send (int 0) :== (send $_ _))
+           (send (send $_ _) :<  (int 1))
+           (send (int 1) :> (send $_ _))}
+        END
+
+        def_node_matcher :other_receiver, <<-END
+          {(send (send $_ _) _ _)
+           (send _ _ (send $_ _))}
+        END
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/team.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # FIXME
+    class Team
+      # If these cops try to autocorrect the same file at the same time,
+      # bad things are liable to happen
+      INCOMPATIBLE_COPS = {
+        Style::SymbolProc => [Layout::SpaceBeforeBlockBraces],
+        Layout::SpaceBeforeBlockBraces => [Style::SymbolProc],
+        Style::LineEndConcatenation => [Style::UnneededInterpolation],
+        Style::UnneededInterpolation => [Style::LineEndConcatenation],
+        Style::SelfAssignment => [Layout::SpaceAroundOperators],
+        Layout::SpaceAroundOperators => [Style::SelfAssignment],
+        Style::BracesAroundHashParameters => [Layout::MultilineHashBraceLayout]
+      }.freeze
+
+      DEFAULT_OPTIONS = {
+        auto_correct: false,
+        debug: false
+      }.freeze
+
+      Investigation = Struct.new(:offenses, :errors)
+
+      attr_reader :errors, :warnings, :updated_source_file
+
+      alias updated_source_file? updated_source_file
+
+      def initialize(cop_classes, config, options = nil)
+        @cop_classes = cop_classes
+        @config = config
+        @options = options || DEFAULT_OPTIONS
+        @errors = []
+        @warnings = []
+
+        validate_config
+      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)
+        end
+
+        offenses(processed_source)
+      end
+
+      def cops
+        only_options = @options.fetch(:only, [])
+        @cops ||= @cop_classes.enabled(@config, only_options).map do |cop_class|
+          cop_class.new(@config, @options)
+        end
+      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
+      end
+
+      private
+
+      def offenses(processed_source)
+        # 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
+        autocorrect_cops, other_cops = cops.partition(&:autocorrect?)
+
+        autocorrect =
+          investigate(autocorrect_cops, processed_source) do |offenses|
+            # 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 offenses if autocorrect(processed_source.buffer,
+                                           autocorrect_cops)
+          end
+
+        other = investigate(other_cops, processed_source)
+
+        errors = autocorrect.errors.merge(other.errors)
+        process_commissioner_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))
+        offenses = commissioner.investigate(processed_source)
+        yield offenses if block_given?
+
+        Investigation.new(offenses, commissioner.errors)
+      end
+
+      def autocorrect_all_cops(buffer, cops)
+        corrector = Corrector.new(buffer)
+        skip = Set.new
+
+        cops.each do |cop|
+          next if cop.corrections.empty?
+          next if skip.include?(cop.class)
+          corrector.corrections.concat(cop.corrections)
+          incompatible = INCOMPATIBLE_COPS[cop.class]
+          skip.merge(incompatible) if incompatible
+        end
+
+        if !corrector.corrections.empty?
+          corrector.rewrite
+        else
+          buffer.source
+        end
+      end
+
+      def validate_config
+        cops.each do |cop|
+          cop.validate_config if cop.respond_to?(:validate_config)
+        end
+      end
+
+      def process_commissioner_errors(file, file_errors)
+        file_errors.each do |cop, errors|
+          errors.each do |cop_error|
+            e = cop_error.error
+            line = ":#{cop_error.line}" if cop_error.line
+            column = ":#{cop_error.column}" if cop_error.column
+            location = "#{file}#{line}#{column}"
+
+            if e.is_a?(Warning)
+              handle_warning(e, location)
+            else
+              handle_error(e, location, cop)
+            end
+          end
+        end
+      end
+
+      def handle_warning(e, location)
+        message = Rainbow("#{e.message} (from file: #{location})").yellow
+
+        @warnings << message
+        warn message
+        puts e.backtrace if debug?
+      end
+
+      def handle_error(e, location, cop)
+        message = Rainbow("An error occurred while #{cop.name}" \
+                           " cop was inspecting #{location}.").red
+        @errors << message
+        warn message
+        if debug?
+          puts e.message, e.backtrace
+        else
+          warn 'To see the complete backtrace run rubbycop -d.'
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/util.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+# rubbycop:disable Metrics/ModuleLength
+module RubbyCop
+  module Cop
+    # This module contains a collection of useful utility methods.
+    module Util
+      include PathUtil
+      extend RubbyCop::AST::Sexp
+
+      BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+
+      EQUALS_ASGN_NODES = %i[lvasgn ivasgn cvasgn gvasgn
+                             casgn masgn].freeze
+      SHORTHAND_ASGN_NODES = %i[op_asgn or_asgn and_asgn].freeze
+      ASGN_NODES = (EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES).freeze
+
+      MODIFIER_NODES = %i[if while until].freeze
+      CONDITIONAL_NODES = (MODIFIER_NODES + [:case]).freeze
+      LOGICAL_OPERATOR_NODES = %i[and or].freeze
+
+      # http://phrogz.net/programmingruby/language.html#table_18.4
+      # Backtick is added last just to help editors parse this code.
+      OPERATOR_METHODS = %w(
+        | ^ & <=> == === =~ > >= < <= << >>
+        + - * / % ** ~ +@ -@ [] []= ! != !~
+      ).map(&:to_sym).push(:'`').freeze
+
+      # Match literal regex characters, not including anchors, character
+      # classes, alternatives, groups, repetitions, references, etc
+      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/
+
+      module_function
+
+      def operator?(symbol)
+        OPERATOR_METHODS.include?(symbol)
+      end
+
+      def strip_quotes(str)
+        if str[0] == '"' || str[0] == "'"
+          str[0] = ''
+        else
+          # we're dealing with %q or %Q
+          str[0, 3] = ''
+        end
+        str[-1] = ''
+
+        str
+      end
+
+      def block_length(block_node)
+        block_node.loc.end.line - block_node.loc.begin.line
+      end
+
+      def comment_line?(line_source)
+        line_source =~ /^\s*#/
+      end
+
+      def line_range(arg)
+        source_range = case arg
+                       when Parser::Source::Range
+                         arg
+                       when Parser::AST::Node
+                         arg.source_range
+                       else
+                         raise ArgumentError, "Invalid argument #{arg}"
+                       end
+
+        source_range.begin.line..source_range.end.line
+      end
+
+      def parentheses?(node)
+        node.loc.respond_to?(:end) && node.loc.end &&
+          node.loc.end.is?(')'.freeze)
+      end
+
+      def parenthesized_call?(send)
+        send.loc.begin && send.loc.begin.is?('(')
+      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 source_range(source_buffer, line_number, column, length = 1)
+        if column.is_a?(Range)
+          column_index = column.begin
+          length = column.size
+        else
+          column_index = column
+        end
+
+        line_begin_pos = if line_number.zero?
+                           0
+                         else
+                           source_buffer.line_range(line_number).begin_pos
+                         end
+        begin_pos = line_begin_pos + column_index
+        end_pos = begin_pos + length
+
+        Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+      end
+
+      # Returns the column attribute of the range, except if the range is on
+      # the first line and there's a byte order mark at the beginning of that
+      # line, in which case 1 is subtracted from the column value. This gives
+      # the column as it appears when viewing the file in an editor.
+      def effective_column(range)
+        if range.line == 1 &&
+           @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
+          range.column - 1
+        else
+          range.column
+        end
+      end
+
+      def range_between(start_pos, end_pos)
+        Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
+      end
+
+      def range_with_surrounding_comma(range, side = :both)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        begin_pos = move_pos(src, begin_pos, -1, go_left, /,/)
+        end_pos = move_pos(src, end_pos, 1, go_right, /,/)
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_with_surrounding_space(range, side = :both, with_newline = true)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        begin_pos = move_pos(src, begin_pos, -1, go_left, /[ \t]/)
+        begin_pos = move_pos(src, begin_pos, -1, go_left && with_newline, /\n/)
+        end_pos = move_pos(src, end_pos, 1, go_right, /[ \t]/)
+        end_pos = move_pos(src, end_pos, 1, go_right && with_newline, /\n/)
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_by_whole_lines(range, include_final_newline: false)
+        buffer = @processed_source.buffer
+
+        begin_pos = range.begin_pos
+        begin_offset = range.column
+        begin_of_first_line = begin_pos - begin_offset
+
+        last_line = buffer.source_line(range.last_line)
+        end_pos = range.end_pos
+        end_offset = last_line.length - range.last_column
+        end_offset += 1 if include_final_newline
+        end_of_last_line = end_pos + end_offset
+
+        Parser::Source::Range.new(buffer, begin_of_first_line, end_of_last_line)
+      end
+
+      def move_pos(src, pos, step, condition, regexp)
+        offset = step == -1 ? -1 : 0
+        pos += step while condition && src[pos + offset] =~ regexp
+        pos < 0 ? 0 : pos
+      end
+
+      def directions(side)
+        if side == :both
+          [true, true]
+        else
+          [side == :left, side == :right]
+        end
+      end
+
+      def begins_its_line?(range)
+        (range.source_line =~ /\S/) == range.column
+      end
+
+      def ends_its_line?(range)
+        line = range.source_buffer.source_line(range.last_line)
+        (line =~ /\s*\z/) == range.last_column
+      end
+
+      def within_node?(inner, outer)
+        o = outer.is_a?(AST::Node) ? outer.source_range : outer
+        i = inner.is_a?(AST::Node) ? inner.source_range : inner
+        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
+      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
+            receiver, _method_name, _args = *node
+            node = receiver
+          when :block
+            method, _args, _body = *node
+            node = method
+          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 to_symbol_literal(string)
+        if symbol_without_quote?(string)
+          ":#{string}"
+        else
+          ":#{to_string_literal(string)}"
+        end
+      end
+
+      def symbol_without_quote?(string)
+        special_gvars = %w[
+          $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+          $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+        ]
+        redefinable_operators = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        )
+
+        # method name
+        string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
+          # instance / class variable
+          string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
+          # global variable
+          string =~ /\A\$[1-9]\d*\z/ ||
+          string =~ /\A\$[a-zA-Z_]\w*\z/ ||
+          special_gvars.include?(string) ||
+          redefinable_operators.include?(string)
+      end
+
+      def interpret_string_escapes(string)
+        StringInterpreter.interpret(string)
+      end
+
+      def same_line?(n1, n2)
+        n1.respond_to?(:loc) &&
+          n2.respond_to?(:loc) &&
+          n1.loc.line == n2.loc.line
+      end
+
+      def line_distance(n1, n2)
+        n2.loc.line - n1.loc.line
+      end
+
+      def preceed?(n1, n2)
+        line_distance(n1, n2) == 1
+      end
+
+      def stripped_source_upto(line)
+        processed_source[0..line].map(&:strip)
+      end
+
+      def compatible_external_encoding_for?(src)
+        src = src.dup if RUBY_VERSION < '2.3'
+        src.force_encoding(Encoding.default_external).valid_encoding?
+      end
+
+      def to_supported_styles(enforced_style)
+        enforced_style
+          .sub(/^Enforced/, 'Supported')
+          .sub('Style', 'Styles')
+      end
+    end
+  end
+end