rubocop 0.82.0 → 0.86.0

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

@@ -174,7 +174,7 @@ module RuboCop
         end
 
         def unparenthesized_method_call?(child)
-          method_name(child) =~ /^[a-z]/i && !child.parenthesized?
+          /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
         end
 
         def below_ternary_precedence?(child)
@@ -199,9 +199,7 @@ module RuboCop
             # Ruby allows no space between the question mark and parentheses.
             # If we remove the parentheses, we need to add a space or we'll
             # generate invalid code.
-            unless whitespace_after?(condition)
-              corrector.insert_after(condition.loc.end, ' ')
-            end
+            corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
           end
         end
 

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

@@ -6,11 +6,11 @@ module RuboCop
       # This cop checks for trailing comma in argument lists.
       # The supported styles are:
       #
-      # - `consistent_comma`: Requires a comma after the last argument,
+      # * `consistent_comma`: Requires a comma after the last argument,
       # for all parenthesized method calls with arguments.
-      # - `comma`: Requires a comma after the last argument, but only for
+      # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
-      # - `no_comma`: Requires that there is no comma after the last
+      # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -6,11 +6,11 @@ module RuboCop
       # This cop checks for trailing comma in array literals.
       # The configuration options are:
       #
-      # - `consistent_comma`: Requires a comma after the
+      # * `consistent_comma`: Requires a comma after the
       # last item of all non-empty, multiline array literals.
-      # - `comma`: Requires a comma after last item in an array,
+      # * `comma`: Requires a comma after last item in an array,
       # but only when each item is on its own line.
-      # - `no_comma`: Does not requires a comma after the
+      # * `no_comma`: Does not requires a comma after the
       # last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -12,7 +12,7 @@ module RuboCop
       #   # bad
       #   add { |foo, bar,| foo + bar }
       #
-      #    # good
+      #   # good
       #   add { |foo, bar| foo + bar }
       #
       #   # good
@@ -22,24 +22,24 @@ module RuboCop
       #   add { foo }
       #
       #   # bad
-      #  add do |foo, bar,|
-      #    foo + bar
+      #   add do |foo, bar,|
+      #     foo + bar
       #   end
       #
-      #  # good
-      #  add do |foo, bar|
-      #    foo + bar
-      #  end
+      #   # good
+      #   add do |foo, bar|
+      #     foo + bar
+      #   end
       #
-      #  # good
+      #   # good
       #   add do |foo,|
-      #    foo
-      #  end
+      #     foo
+      #   end
       #
-      #  # good
-      #  add do
+      #   # good
+      #   add do
       #     foo + bar
-      #  end
+      #   end
       class TrailingCommaInBlockArgs < Cop
         MSG = 'Useless trailing comma present in block arguments.'
 

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

@@ -6,11 +6,11 @@ module RuboCop
       # This cop checks for trailing comma in hash literals.
       # The configuration options are:
       #
-      # - `consistent_comma`: Requires a comma after the
+      # * `consistent_comma`: Requires a comma after the
       # last item of all non-empty, multiline hash literals.
-      # - `comma`: Requires a comma after the last item in a hash,
+      # * `comma`: Requires a comma after the last item in a hash,
       # but only when each item is on its own line.
-      # - `no_comma`: Does not requires a comma after the
+      # * `no_comma`: Does not requires a comma after the
       # last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -126,9 +126,7 @@ module RuboCop
             return unused_range(node.type, mlhs_node, right)
           end
 
-          if Util.parentheses?(mlhs_node)
-            return range_for_parentheses(first_offense, mlhs_node)
-          end
+          return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
 
           range_between(first_offense.source_range.begin_pos,
                         node.loc.operator.begin_pos)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for *unless* expressions with *else* clauses.
+      # This cop looks for `unless` expressions with `else` clauses.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for *when;* uses in *case* expressions.
+      # This cop checks for `when;` uses in `case` expressions.
       #
       # @example
       #   # bad

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

@@ -73,7 +73,7 @@ module RuboCop
           strings.any? do |s|
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
             !string.valid_encoding? ||
-              string !~ word_regex || string =~ / /
+              !word_regex.match?(string) || / /.match?(string)
           end
         end
 

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

@@ -19,6 +19,8 @@ module RuboCop
       #   foo == "bar"
       #   foo <= 42
       #   bar > 10
+      #   "#{interpolation}" == foo
+      #   /#{interpolation}/ == foo
       #
       # @example EnforcedStyle: forbid_for_equality_operators_only
       #   # bad
@@ -109,7 +111,8 @@ module RuboCop
           rhs = node.first_argument
 
           return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal?
+                         !lhs.literal? && !rhs.literal? ||
+                         interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?
         end
@@ -150,6 +153,20 @@ module RuboCop
         def program_name?(name)
           PROGRAM_NAMES.include?(name)
         end
+
+        def interpolation?(node)
+          return true if node.dstr_type?
+
+          # TODO: Use `RegexpNode#interpolation?` when the following is released.
+          # https://github.com/rubocop-hq/rubocop-ast/pull/18
+          if node.regexp_type?
+            return true if node.children.any? do |child|
+              child.respond_to?(:begin_type?) && child.begin_type?
+            end
+          end
+
+          false
+        end
       end
     end
   end

data/lib/rubocop/cop/team.rb

@@ -2,7 +2,13 @@
 
 module RuboCop
   module Cop
-    # FIXME
+    # 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,
@@ -11,12 +17,12 @@ module RuboCop
 
       Investigation = Struct.new(:offenses, :errors)
 
-      attr_reader :errors, :warnings, :updated_source_file
+      attr_reader :errors, :warnings, :updated_source_file, :cops
 
       alias updated_source_file? updated_source_file
 
-      def initialize(cop_classes, config, options = nil)
-        @cop_classes = cop_classes
+      def initialize(cops, config = nil, options = nil)
+        @cops = cops
         @config = config
         @options = options || DEFAULT_OPTIONS
         @errors = []
@@ -25,6 +31,31 @@ module RuboCop
         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
@@ -44,14 +75,6 @@ module RuboCop
         offenses(processed_source)
       end
 
-      def cops
-        only = @options.fetch(:only, [])
-        safe = @options.fetch(:safe, false)
-        @cops ||= @cop_classes.enabled(@config, only, safe).map do |cop_class|
-          cop_class.new(@config, @options)
-        end
-      end
-
       def forces
         @forces ||= forces_for(cops)
       end
@@ -93,21 +116,23 @@ module RuboCop
 
       private
 
-      def offenses(processed_source)
+      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
-        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
+        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)
 
@@ -120,13 +145,32 @@ module RuboCop
       def investigate(cops, processed_source)
         return Investigation.new([], {}) if cops.empty?
 
-        commissioner = Commissioner.new(cops, forces_for(cops))
+        commissioner = Commissioner.new(cops, forces_for(cops), @options)
         offenses = commissioner.investigate(processed_source)
-        yield offenses if block_given?
 
         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)
 

data/lib/rubocop/cop/util.rb

@@ -14,7 +14,11 @@ module RuboCop
       module_function
 
       def comment_line?(line_source)
-        line_source =~ /^\s*#/
+        /^\s*#/.match?(line_source)
+      end
+
+      def comment_lines?(node)
+        processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
 
       def line_range(node)
@@ -26,6 +30,26 @@ module RuboCop
           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?
 
@@ -64,7 +88,7 @@ module RuboCop
 
         # 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
+        /'|(?<! \\) \\{2}* \\ (?![\\"])/x.match?(string)
       end
 
       def needs_escaping?(string)
@@ -84,7 +108,7 @@ module RuboCop
       end
 
       def trim_string_interporation_escape_character(str)
-        str.gsub(/\\\#{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
+        str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       end
 
       def interpret_string_escapes(string)

data/lib/rubocop/cop/utils/format_string.rb

@@ -97,6 +97,10 @@ module RuboCop
           @format_sequences ||= parse
         end
 
+        def valid?
+          !mixed_formats?
+        end
+
         def named_interpolation?
           format_sequences.any?(&:name)
         end
@@ -114,6 +118,20 @@ module RuboCop
             )
           end
         end
+
+        def mixed_formats?
+          formats = format_sequences.reject(&:percent?).map do |seq|
+            if seq.name
+              :named
+            elsif seq.max_digit_dollar_num
+              :numbered
+            else
+              :unnumbered
+            end
+          end
+
+          formats.uniq.size > 1
+        end
       end
     end
   end

data/lib/rubocop/cop/variable_force.rb

@@ -152,9 +152,7 @@ module RuboCop
       def process_variable_assignment(node)
         name = node.children.first
 
-        unless variable_table.variable_exist?(name)
-          variable_table.declare_variable(name, node)
-        end
+        variable_table.declare_variable(name, node) unless variable_table.variable_exist?(name)
 
         # Need to scan rhs before assignment so that we can mark previous
         # assignments as referenced if rhs has referencing to the variable
@@ -211,9 +209,7 @@ module RuboCop
 
         name = asgn_node.children.first
 
-        unless variable_table.variable_exist?(name)
-          variable_table.declare_variable(name, asgn_node)
-        end
+        variable_table.declare_variable(name, asgn_node) unless variable_table.variable_exist?(name)
 
         # The following statements:
         #
@@ -369,9 +365,7 @@ module RuboCop
           AssignmentReference.new(node)
         when *OPERATOR_ASSIGNMENT_TYPES
           asgn_node = node.children.first
-          if asgn_node.lvasgn_type?
-            VariableReference.new(asgn_node.children.first)
-          end
+          VariableReference.new(asgn_node.children.first) if asgn_node.lvasgn_type?
         end
       end