rubocop 0.49.1 → 0.50.0

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

@@ -9,18 +9,34 @@ module RuboCop
       #
       # @example
       #
+      #   # EnforcedStyle: all_comparison_operators
+      #
       #   # 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
+        include ConfigurableEnforcedStyle
+
         MSG = 'Reverse the order of the operands `%s`.'.freeze
 
         REVERSE_COMPARISON = {
@@ -30,26 +46,33 @@ 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
 
         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
+
+          return false if noncommutative_operator?(operator)
 
-        def comparison_operator?(node)
-          RuboCop::AST::Node::COMPARISON_OPERATORS.include?(node.method_name)
+          lhs.literal? && !rhs.literal?
         end
 
-        def register_offense(node)
-          add_offense(node, :expression, format(MSG, node.source))
+        def message(node)
+          format(MSG, node.source)
         end
 
         def autocorrect(node)
@@ -59,8 +82,8 @@ module RuboCop
         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 +95,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

@@ -31,34 +31,41 @@ module RuboCop
         NONZERO_MSG = 'Use `!empty?` instead of `%s %s %s`.'.freeze
 
         def on_send(node)
+          check_zero_length_predicate(node)
+          check_nonzero_length_predicate(node)
+        end
+
+        private
+
+        def check_zero_length_predicate(node)
           zero_length_predicate = zero_length_predicate(node)
 
-          if zero_length_predicate
-            add_offense(node, :expression,
-                        format(ZERO_MSG, *zero_length_predicate))
-          end
+          return unless zero_length_predicate
 
+          add_offense(node, :expression,
+                      format(ZERO_MSG, *zero_length_predicate))
+        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
+
+          add_offense(node, :expression,
+                      format(NONZERO_MSG, *nonzero_length_predicate))
         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
+        PATTERN
 
         def autocorrect(node)
           lambda do |corrector|
@@ -73,17 +80,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

@@ -304,6 +304,17 @@ module RuboCop
           .sub(/^Enforced/, 'Supported')
           .sub('Style', 'Styles')
       end
+
+      def scrub_string(string)
+        if string.respond_to?(:scrub)
+          string.scrub
+        else
+          string
+            .encode('UTF-16BE', 'UTF-8',
+                    invalid: :replace, undef: :replace, replace: '?')
+            .encode('UTF-8')
+        end
+      end
     end
   end
 end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -50,7 +50,7 @@ module RuboCop
         output.puts HEADING % command
 
         # Syntax isn't a real cop and it can't be disabled.
-        @cops_with_offenses.delete('Syntax')
+        @cops_with_offenses.delete('Lint/Syntax')
 
         output_offenses
 

data/lib/rubocop/formatter/formatter_set.rb

@@ -19,7 +19,8 @@ module RuboCop
         'files'    => FileListFormatter,
         'offenses' => OffenseCountFormatter,
         'disabled' => DisabledLinesFormatter,
-        'worst'    => WorstOffendersFormatter
+        'worst'    => WorstOffendersFormatter,
+        'tap'      => TapFormatter
       }.freeze
 
       FORMATTER_APIS = %i[started finished].freeze

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -27,6 +27,7 @@ module RuboCop
         report_summary(@offense_counts)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def report_summary(offense_counts)
         per_cop_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
@@ -42,6 +43,7 @@ module RuboCop
 
         output.puts
       end
+      # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
         Hash[offense_counts.sort_by { |k, v| [-v, k] }]

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -70,7 +70,7 @@ module RuboCop
       end
 
       def annotate_message(msg)
-        msg.gsub(/`(.*?)`/, yellow('\1'))
+        msg.gsub(/`(.*?)`/m, yellow('\1'))
       end
 
       def message(offense)

data/lib/rubocop/formatter/tap_formatter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter formats report data using the Test Anything Protocol.
+    # TAP allows for to communicate tests results in a language agnostics way.
+    class TapFormatter < ClangStyleFormatter
+      def started(target_files)
+        super
+        @progress_count = 1
+        output.puts "1..#{target_files.size}"
+      end
+
+      def file_finished(file, offenses)
+        if offenses.empty?
+          output.puts "ok #{@progress_count} - #{smart_path(file)}"
+        else
+          output.puts "not ok #{@progress_count} - #{smart_path(file)}"
+
+          count_stats(offenses)
+          report_file(file, offenses)
+        end
+
+        @progress_count += 1
+      end
+
+      private
+
+      def report_line(location)
+        source_line = location.source_line
+
+        if location.first_line == location.last_line
+          output.puts("# #{source_line}")
+        else
+          output.puts("# #{source_line} #{yellow(ELLIPSES)}")
+        end
+      end
+
+      def report_highlighted_area(highlighted_area)
+        output.puts("# #{' ' * highlighted_area.begin_pos}" \
+                    "#{'^' * highlighted_area.size}")
+      end
+
+      def report_offense(file, offense)
+        output.printf("# %s:%d:%d: %s: %s\n",
+                      cyan(smart_path(file)), offense.line, offense.real_column,
+                      colored_severity_code(offense), message(offense))
+
+        # rubocop:disable Lint/HandleExceptions
+        begin
+          return unless valid_line?(offense)
+
+          report_line(offense.location)
+          report_highlighted_area(offense.highlighted_area)
+        rescue IndexError
+          # range is not on a valid line; perhaps the source file is empty
+        end
+        # rubocop:enable Lint/HandleExceptions
+      end
+
+      def annotate_message(msg)
+        msg.gsub(/`(.*?)`/, '\1')
+      end
+
+      def message(offense)
+        message = offense.corrected? ? '[Corrected] ' : ''
+        "#{message}#{annotate_message(offense.message)}"
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -32,6 +32,7 @@ module RuboCop
         report_summary(@offense_counts)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def report_summary(offense_counts)
         per_file_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
@@ -47,6 +48,7 @@ module RuboCop
 
         output.puts
       end
+      # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
         Hash[offense_counts.sort_by { |k, v| [-v, k] }]

data/lib/rubocop/node_pattern.rb

@@ -98,19 +98,26 @@ module RuboCop
     # @private
     # Builds Ruby code which implements a pattern
     class Compiler
-      RSYM    = %r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}
-      ID_CHAR = /[a-zA-Z_-]/
-      META    = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
-      NUMBER  = /-?\d+(?:\.\d+)?/
-      TOKEN   =
-        /\G(?:[\s,]+|#{META}|%\d*|#{NUMBER}|\#?#{ID_CHAR}+[\!\?]?\(?|#{RSYM}|.)/
-
-      NODE      = /\A#{ID_CHAR}+\Z/
-      PREDICATE = /\A#{ID_CHAR}+\?\(?\Z/
-      WILDCARD  = /\A_#{ID_CHAR}*\Z/
-      FUNCALL   = /\A\##{ID_CHAR}+[\!\?]?\(?\Z/
-      LITERAL   = /\A(?:#{RSYM}|#{NUMBER}|nil)\Z/
-      PARAM     = /\A%\d*\Z/
+      SYMBOL       = %r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}
+      IDENTIFIER   = /[a-zA-Z_-]/
+      META         = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
+      NUMBER       = /-?\d+(?:\.\d+)?/
+      STRING       = /".+?"/
+      METHOD_NAME  = /\#?#{IDENTIFIER}+[\!\?]?\(?/
+      PARAM_NUMBER = /%\d*/
+
+      SEPARATORS = /[\s]+/
+      TOKENS     = Regexp.union(META, PARAM_NUMBER, NUMBER,
+                                METHOD_NAME, SYMBOL, STRING)
+
+      TOKEN = /\G(?:#{SEPARATORS}|#{TOKENS}|.)/
+
+      NODE      = /\A#{IDENTIFIER}+\Z/
+      PREDICATE = /\A#{IDENTIFIER}+\?\(?\Z/
+      WILDCARD  = /\A_#{IDENTIFIER}*\Z/
+      FUNCALL   = /\A\##{METHOD_NAME}/
+      LITERAL   = /\A(?:#{SYMBOL}|#{NUMBER}|#{STRING}|nil)\Z/
+      PARAM     = /\A#{PARAM_NUMBER}\Z/
       CLOSING   = /\A(?:\)|\}|\])\Z/
 
       attr_reader :match_code
@@ -128,9 +135,11 @@ module RuboCop
       end
 
       def run(node_var)
-        tokens = @string.scan(TOKEN)
-        tokens.reject! { |token| token =~ /\A[\s,]+\Z/ } # drop whitespace
+        tokens =
+          @string.scan(TOKEN).reject { |token| token =~ /\A#{SEPARATORS}\Z/ }
+
         @match_code = compile_expr(tokens, node_var, false)
+
         fail_due_to('unbalanced pattern') unless tokens.empty?
       end
 
@@ -158,7 +167,7 @@ module RuboCop
         when PARAM     then compile_param(cur_node, token[1..-1], seq_head)
         when CLOSING   then fail_due_to("#{token} in invalid position")
         when nil       then fail_due_to('pattern ended prematurely')
-        else fail_due_to("invalid token #{token.inspect}")
+        else                fail_due_to("invalid token #{token.inspect}")
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
@@ -336,7 +345,8 @@ module RuboCop
         else
           n = @unify[name] = next_temp_value
           # double assign to temp#{n} to avoid "assigned but unused variable"
-          "(temp#{n} = temp#{n} = #{cur_node}#{'.type' if seq_head}; true)"
+          "(temp#{n} = #{cur_node}#{'.type' if seq_head}; " \
+          "temp#{n} = temp#{n}; true)"
         end
       end
 
@@ -433,11 +443,17 @@ module RuboCop
         params.empty? ? '' : ",#{params}"
       end
 
+      def emit_guard_clause
+        <<-RUBY
+          return unless node.is_a?(RuboCop::AST::Node)
+        RUBY
+      end
+
       def emit_method_code
-        <<-CODE
-          return nil unless #{@match_code}
+        <<-RUBY
+          return unless #{@match_code}
           block_given? ? yield(#{emit_capture_list}) : (return #{emit_retval})
-        CODE
+        RUBY
       end
 
       def fail_due_to(message)
@@ -447,7 +463,7 @@ module RuboCop
       def with_temp_node(cur_node)
         with_temp_variable do |temp_var|
           # double assign to temp#{n} to avoid "assigned but unused variable"
-          yield "#{temp_var} = #{temp_var} = #{cur_node}", temp_var
+          yield "#{temp_var} = #{cur_node}; #{temp_var} = #{temp_var}", temp_var
         end
       end
 
@@ -459,6 +475,7 @@ module RuboCop
         @temps += 1
       end
     end
+    private_constant :Compiler
 
     # Helpers for defining methods based on a pattern string
     module Macros
@@ -470,9 +487,10 @@ module RuboCop
       # If the node matches, and no block is provided, the new method will
       # return the captures, or `true` if there were none.
       def def_node_matcher(method_name, pattern_str)
-        compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
-        src = "def #{method_name}(node" \
+        compiler = Compiler.new(pattern_str, 'node')
+        src = "def #{method_name}(node = self" \
               "#{compiler.emit_trailing_params});" \
+              "#{compiler.emit_guard_clause}" \
               "#{compiler.emit_method_code};end"
 
         location = caller_locations(1, 1).first
@@ -486,7 +504,7 @@ module RuboCop
       # as soon as it finds a descendant which matches. Otherwise, it will
       # yield all descendants which match.
       def def_node_search(method_name, pattern_str)
-        compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
+        compiler = Compiler.new(pattern_str, 'node')
         called_from = caller(1..1).first.split(':')
 
         if method_name.to_s.end_with?('?')
@@ -519,7 +537,7 @@ module RuboCop
 
       def node_search_body(method_name, trailing_params, prelude, match_code,
                            on_match)
-        <<-END
+        <<-RUBY
           def #{method_name}(node0#{trailing_params})
             #{prelude}
             node0.each_node do |node|
@@ -529,7 +547,7 @@ module RuboCop
             end
             nil
           end
-        END
+        RUBY
       end
     end