rubocop 0.49.1 → 0.52.0

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

@@ -7,21 +7,31 @@ module RuboCop
       # readability is reduced because the operands are not ordered the same
       # way as they would be ordered in spoken English.
       #
-      # @example
-      #
+      # @example EnforcedStyle: all_comparison_operators (default)
       #   # bad
       #   99 == foo
-      #   "bar" == foo
+      #   "bar" != foo
       #   42 >= foo
-      #
-      # @example
+      #   10 < bar
       #
       #   # good
       #   foo == 99
       #   foo == "bar"
-      #   for <= 42
+      #   foo <= 42
+      #   bar > 10
+      #
+      # @example EnforcedStyle: equality_operators_only
+      #   # bad
+      #   99 == foo
+      #   "bar" != foo
+      #
+      #   # good
+      #   99 >= foo
+      #   3 < a && a < 5
       class YodaCondition < Cop
-        MSG = 'Reverse the order of the operands `%s`.'.freeze
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Reverse the order of the operands `%<source>s`.'.freeze
 
         REVERSE_COMPARISON = {
           '<' => '>',
@@ -30,37 +40,44 @@ module RuboCop
           '>=' => '<='
         }.freeze
 
+        EQUALITY_OPERATORS = %i[== !=].freeze
+
+        NONCOMMUTATIVE_OPERATORS = %i[===].freeze
+
         def on_send(node)
           return unless yoda_condition?(node)
 
-          register_offense(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 comparison_operator?(node)
+          return false unless node.comparison_method?
 
-          node.receiver.literal? && !node.arguments.first.literal?
-        end
+          lhs, operator, rhs = *node
+          if check_equality_only?
+            return false if non_equality_operator?(operator)
+          end
 
-        def comparison_operator?(node)
-          RuboCop::AST::Node::COMPARISON_OPERATORS.include?(node.method_name)
-        end
+          return false if noncommutative_operator?(operator)
 
-        def register_offense(node)
-          add_offense(node, :expression, format(MSG, node.source))
+          lhs.literal? && !rhs.literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(actual_code_range(node), corrected_code(node))
-          end
+        def message(node)
+          format(MSG, source: node.source)
         end
 
         def corrected_code(node)
-          first, operator, last = node.children
-          "#{last.source} #{reverse_comparison(operator)} #{first.source}"
+          lhs, operator, rhs = *node
+          "#{rhs.source} #{reverse_comparison(operator)} #{lhs.source}"
         end
 
         def actual_code_range(node)
@@ -72,6 +89,18 @@ module RuboCop
         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

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

@@ -10,8 +10,7 @@ module RuboCop
       # replaced by receiver.empty? and !receiver.empty.
       #
       # @example
-      #
-      #   @bad
+      #   # bad
       #   [1, 2, 3].length == 0
       #   0 == "foobar".length
       #   array.length < 1
@@ -19,7 +18,7 @@ module RuboCop
       #   string.length > 0
       #   hash.size > 0
       #
-      #   @good
+      #   # good
       #   [1, 2, 3].empty?
       #   "foobar".empty?
       #   array.empty?
@@ -27,44 +26,60 @@ module RuboCop
       #   !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)
 
-          # rubocop:disable Style/GuardClause
-          if nonzero_length_predicate
-            add_offense(node, :expression,
-                        format(NONZERO_MSG, *nonzero_length_predicate))
-          end
-          # rubocop:enable Style/GuardClause
+          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)
@@ -73,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

@@ -36,7 +36,9 @@ 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)
@@ -117,14 +119,8 @@ module RuboCop
 
       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)
-          skip.merge(cop.class.autocorrect_incompatible_with)
-        end
+        collate_corrections(corrector, cops)
 
         if !corrector.corrections.empty?
           corrector.rewrite
@@ -133,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)

data/lib/rubocop/cop/util.rb

@@ -23,7 +23,7 @@ module RuboCop
       # 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
@@ -48,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
@@ -137,18 +133,22 @@ 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
 
@@ -168,20 +168,6 @@ module RuboCop
         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
@@ -282,11 +268,7 @@ module RuboCop
           n1.loc.line == n2.loc.line
       end
 
-      def line_distance(n1, n2)
-        n2.loc.line - n1.loc.line
-      end
-
-      def preceed?(n1, n2)
+      def precede?(n1, n2)
         line_distance(n1, n2) == 1
       end
 
@@ -294,16 +276,43 @@ module RuboCop
         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
+
+      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

data/lib/rubocop/cop/variable_force.rb

@@ -320,7 +320,7 @@ module RuboCop
             next if assignment_nodes_in_loop.none? do |assignment_node|
                       assignment_node.equal?(assignment.node)
                     end
-            assignment.reference!
+            assignment.reference!(node)
           end
         end
       end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -9,7 +9,7 @@ module RuboCop
 
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
-        attr_reader :node, :variable, :referenced
+        attr_reader :node, :variable, :referenced, :references
         alias referenced? referenced
 
         def initialize(node, variable)
@@ -22,6 +22,7 @@ module RuboCop
           @node = node
           @variable = variable
           @referenced = false
+          @references = []
         end
 
         def name
@@ -32,7 +33,8 @@ module RuboCop
           @variable.scope
         end
 
-        def reference!
+        def reference!(node)
+          @references << node
           @referenced = true
         end