rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for Yoda conditions, i.e. comparison operations where
+      # readability is reduced because the operands are not ordered the same
+      # way as they would be ordered in spoken English.
+      #
+      # @example EnforcedStyle: all_comparison_operators (default)
+      #   # bad
+      #   99 == foo
+      #   "bar" != foo
+      #   42 >= foo
+      #   10 < bar
+      #
+      #   # good
+      #   foo == 99
+      #   foo == "bar"
+      #   foo <= 42
+      #   bar > 10
+      #
+      # @example EnforcedStyle: equality_operators_only
+      #   # bad
+      #   99 == foo
+      #   "bar" != foo
+      #
+      #   # good
+      #   99 >= foo
+      #   3 < a && a < 5
+      class YodaCondition < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Reverse the order of the operands `%<source>s`.'.freeze
+
+        REVERSE_COMPARISON = {
+          '<' => '>',
+          '<=' => '>=',
+          '>' => '<',
+          '>=' => '<='
+        }.freeze
+
+        EQUALITY_OPERATORS = %i[== !=].freeze
+
+        NONCOMMUTATIVE_OPERATORS = %i[===].freeze
+
+        def on_send(node)
+          return unless yoda_condition?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(actual_code_range(node), corrected_code(node))
+          end
+        end
+
+        private
+
+        def yoda_condition?(node)
+          return false unless node.comparison_method?
+
+          lhs, operator, rhs = *node
+          if check_equality_only?
+            return false if non_equality_operator?(operator)
+          end
+
+          return false if noncommutative_operator?(operator)
+
+          lhs.literal? && !rhs.literal?
+        end
+
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
+        def corrected_code(node)
+          lhs, operator, rhs = *node
+          "#{rhs.source} #{reverse_comparison(operator)} #{lhs.source}"
+        end
+
+        def actual_code_range(node)
+          range_between(
+            node.loc.expression.begin_pos, node.loc.expression.end_pos
+          )
+        end
+
+        def reverse_comparison(operator)
+          REVERSE_COMPARISON.fetch(operator.to_s, operator)
+        end
+
+        def check_equality_only?
+          style == :equality_operators_only
+        end
+
+        def non_equality_operator?(operator)
+          !EQUALITY_OPERATORS.include?(operator)
+        end
+
+        def noncommutative_operator?(operator)
+          NONCOMMUTATIVE_OPERATORS.include?(operator)
+        end
+      end
+    end
+  end
+end

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

@@ -1,62 +1,85 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for receiver.length == 0 predicates and the
-      # negated versions receiver.length > 0 and receiver.length != 0.
-      # These can be replaced with receiver.empty? and
-      # !receiver.empty? respectively.
+      # 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
+      #   # 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
+      #   # 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
+        ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'.freeze
+        NONZERO_MSG = 'Use `!empty?` instead of ' \
+                      '`%<lhs>s %<opr>s %<rhs>s`.'.freeze
 
         def on_send(node)
-          zero_length_predicate = zero_length_predicate(node)
+          check_zero_length_predicate(node)
+          check_nonzero_length_predicate(node)
+        end
 
-          if zero_length_predicate
-            add_offense(node, :expression,
-                        format(ZERO_MSG, *zero_length_predicate))
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, 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
 
+          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)
 
-          if nonzero_length_predicate
-            add_offense(node, :expression,
-                        format(NONZERO_MSG, *nonzero_length_predicate))
-          end
+          return unless nonzero_length_predicate
+
+          lhs, opr, rhs = nonzero_length_predicate
+
+          add_offense(
+            node,
+            message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          )
         end
 
-        def_node_matcher :zero_length_predicate, <<-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}))}
-        END
+        PATTERN
 
-        def_node_matcher :nonzero_length_predicate, <<-END
+        def_node_matcher :nonzero_length_predicate, <<-PATTERN
           {(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
+        PATTERN
 
         def replacement(node)
           receiver = zero_length_receiver(node)
@@ -65,17 +88,17 @@ module RuboCop
           "!#{other_receiver(node).source}.empty?"
         end
 
-        def_node_matcher :zero_length_receiver, <<-END
+        def_node_matcher :zero_length_receiver, <<-PATTERN
           {(send (send $_ _) :== (int 0))
            (send (int 0) :== (send $_ _))
            (send (send $_ _) :<  (int 1))
            (send (int 1) :> (send $_ _))}
-        END
+        PATTERN
 
-        def_node_matcher :other_receiver, <<-END
+        def_node_matcher :other_receiver, <<-PATTERN
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
-        END
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/team.rb

@@ -1,19 +1,9 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   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 => [Style::SpaceBeforeBlockBraces],
-        Style::SpaceBeforeBlockBraces => [Style::SymbolProc],
-        Style::LineEndConcatenation => [Style::UnneededInterpolation],
-        Style::UnneededInterpolation => [Style::LineEndConcatenation]
-      }.freeze
-
       DEFAULT_OPTIONS = {
         auto_correct: false,
         debug: false
@@ -46,14 +36,17 @@ module RuboCop
       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)
+          return Lint::Syntax.offenses_from_processed_source(
+            processed_source, @config, @options
+          )
         end
 
         offenses(processed_source)
       end
 
       def cops
-        @cops ||= @cop_classes.select { |c| cop_enabled?(c) }.map do |cop_class|
+        only_options = @options.fetch(:only, [])
+        @cops ||= @cop_classes.enabled(@config, only_options).map do |cop_class|
           cop_class.new(@config, @options)
         end
       end
@@ -83,7 +76,7 @@ module RuboCop
           @options[:stdin] = new_source
         else
           filename = buffer.name
-          File.open(filename, 'wb') { |f| f.write(new_source) }
+          File.open(filename, 'w') { |f| f.write(new_source) }
         end
         @updated_source_file = true
       end
@@ -124,22 +117,10 @@ module RuboCop
         Investigation.new(offenses, commissioner.errors)
       end
 
-      def cop_enabled?(cop_class)
-        @config.cop_enabled?(cop_class) ||
-          (@options[:only] || []).include?(cop_class.cop_name)
-      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
+        collate_corrections(corrector, cops)
 
         if !corrector.corrections.empty?
           corrector.rewrite
@@ -148,6 +129,18 @@ module RuboCop
         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)
@@ -156,27 +149,32 @@ module RuboCop
 
       def process_commissioner_errors(file, file_errors)
         file_errors.each do |cop, errors|
-          errors.each do |e|
+          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,
-                             Rainbow("#{e.message} (from file: " \
-                             "#{file})").yellow)
+              handle_warning(e, location)
             else
-              handle_error(e,
-                           Rainbow("An error occurred while #{cop.name}" \
-                           " cop was inspecting #{file}.").red)
+              handle_error(e, location, cop)
             end
           end
         end
       end
 
-      def handle_warning(e, message)
+      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, message)
+      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?

data/lib/rubocop/cop/util.rb

@@ -1,31 +1,34 @@
-# encoding: utf-8
 # frozen_string_literal: true
-# rubocop:disable Metrics/ModuleLength
 
+# rubocop:disable Metrics/ModuleLength
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
     module Util
       include PathUtil
-      extend RuboCop::Sexp
+      extend RuboCop::AST::Sexp
 
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
 
-      EQUALS_ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn,
-                           :casgn, :masgn].freeze
-      SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn].freeze
+      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\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZS0-9]/
+      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/
 
       module_function
 
@@ -45,10 +48,6 @@ module RuboCop
         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
@@ -81,16 +80,13 @@ module RuboCop
         yield sexp if Array(syms).include?(sexp.type)
         return if Array(excludes).include?(sexp.type)
 
-        sexp.children.each do |elem|
-          next unless elem.is_a?(Parser::AST::Node)
-          on_node(syms, elem, excludes, &block)
-        end
+        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 = numeric_range_size(column)
+          length = column.size
         else
           column_index = column
         end
@@ -119,6 +115,10 @@ module RuboCop
         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
@@ -133,33 +133,39 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def range_with_surrounding_space(range, side = :both, with_newline = true)
+      def range_with_surrounding_space(range:,
+                                       side: :both,
+                                       newlines: true,
+                                       whitespace: false)
         buffer = @processed_source.buffer
         src = buffer.source
 
         go_left, go_right = directions(side)
 
         begin_pos = range.begin_pos
+        if go_left
+          begin_pos =
+            final_pos(src, begin_pos, -1, newlines, whitespace)
+        end
         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/)
+        end_pos = final_pos(src, end_pos, 1, newlines, whitespace) if go_right
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       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 range_by_whole_lines(range, include_final_newline: false)
+        buffer = @processed_source.buffer
 
-      def directions(side)
-        if side == :both
-          [true, true]
-        else
-          [side == :left, side == :right]
-        end
+        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 begins_its_line?(range)
@@ -172,8 +178,8 @@ module RuboCop
       end
 
       def within_node?(inner, outer)
-        o = outer.is_a?(Node) ? outer.source_range : outer
-        i = inner.is_a?(Node) ? inner.source_range : inner
+        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
 
@@ -195,14 +201,6 @@ module RuboCop
         node
       end
 
-      # Range#size is not available prior to Ruby 2.0.
-      def numeric_range_size(range)
-        size = range.end - range.begin
-        size += 1 unless range.exclude_end?
-        size = 0 if size < 0
-        size
-      end
-
       # If converting a string to Ruby string literal source code, must
       # double quotes be used?
       def double_quotes_required?(string)
@@ -215,15 +213,6 @@ module RuboCop
         string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
       end
 
-      # If double quoted string literals are found in Ruby code, and they are
-      # not the preferred style, should they be flagged?
-      def double_quotes_acceptable?(string)
-        # If a string literal contains hard-to-type characters which would
-        # not appear on a "normal" keyboard, then double-quotes are acceptable
-        needs_escaping?(string) ||
-          string.codepoints.any? { |cp| cp < 32 || cp > 126 }
-      end
-
       def needs_escaping?(string)
         double_quotes_required?(escape_string(string))
       end
@@ -233,7 +222,7 @@ module RuboCop
       end
 
       def to_string_literal(string)
-        if needs_escaping?(string)
+        if needs_escaping?(string) && compatible_external_encoding_for?(string)
           string.inspect
         else
           "'#{string.gsub('\\') { '\\\\' }}'"
@@ -241,12 +230,89 @@ module RuboCop
       end
 
       def to_symbol_literal(string)
-        ":#{string.to_sym}"
+        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 precede?(n1, n2)
+        line_distance(n1, n2) == 1
+      end
+
+      def stripped_source_upto(line)
+        processed_source[0..line].map(&:strip)
+      end
+
+      def to_supported_styles(enforced_style)
+        enforced_style
+          .sub(/^Enforced/, 'Supported')
+          .sub('Style', 'Styles')
+      end
+
+      private
+
+      def directions(side)
+        if side == :both
+          [true, true]
+        else
+          [side == :left, side == :right]
+        end
+      end
+
+      def final_pos(src, pos, increment, newlines, whitespace)
+        pos = move_pos(src, pos, increment, true, /[ \t]/)
+        pos = move_pos(src, pos, increment, newlines, /\n/)
+        move_pos(src, pos, increment, whitespace, /\s/)
+      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 compatible_external_encoding_for?(src)
+        src = src.dup if RUBY_VERSION < '2.3' || RUBY_ENGINE == 'jruby'
+        src.force_encoding(Encoding.default_external).valid_encoding?
+      end
+
+      def line_distance(n1, n2)
+        n2.loc.line - n1.loc.line
+      end
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength