rubocop 1.9.1 → 1.22.3

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

@@ -8,6 +8,25 @@ module RuboCop
       # that comma to be present. Blocks with more than one argument never
       # require a trailing comma.
       #
+      # @safety
+      #   This cop is unsafe because a trailing comma can indicate there are
+      #   more parameters that are not used.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   # with a trailing comma
+      #   {foo: 1, bar: 2, baz: 3}.map {|key,| key }
+      #   #=> [:foo, :bar, :baz]
+      #
+      #   # without a trailing comma
+      #   {foo: 1, bar: 2, baz: 3}.map {|key| key }
+      #   #=> [[:foo, 1], [:bar, 2], [:baz, 3]]
+      #   ----
+      #
+      #   This can be fixed by replacing the trailing comma with a placeholder
+      #   argument (such as `|key, _value|`).
+      #
       # @example
       #   # bad
       #   add { |foo, bar,| foo + bar }
@@ -52,9 +71,7 @@ module RuboCop
 
           last_comma_pos = last_comma(node).pos
 
-          add_offense(last_comma_pos) do |corrector|
-            corrector.replace(last_comma_pos, '')
-          end
+          add_offense(last_comma_pos) { |corrector| corrector.replace(last_comma_pos, '') }
         end
 
         private
@@ -78,9 +95,7 @@ module RuboCop
         def argument_tokens(node)
           tokens = processed_source.tokens_within(node)
           pipes = tokens.select { |token| token.type == :tPIPE }
-          begin_pos, end_pos = pipes.map do |pipe|
-            tokens.index(pipe)
-          end
+          begin_pos, end_pos = pipes.map { |pipe| tokens.index(pipe) }
 
           tokens[begin_pos + 1..end_pos - 1]
         end

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

@@ -36,11 +36,10 @@ module RuboCop
       class TrailingMethodEndStatement < Base
         extend AutoCorrector
 
-        MSG = 'Place the end statement of a multi-line method on ' \
-              'its own line.'
+        MSG = 'Place the end statement of a multi-line method on its own line.'
 
         def on_def(node)
-          return unless trailing_end?(node)
+          return if node.endless? || !trailing_end?(node)
 
           add_offense(node.loc.end) do |corrector|
             corrector.insert_before(
@@ -53,9 +52,7 @@ module RuboCop
         private
 
         def trailing_end?(node)
-          node.body &&
-            node.multiline? &&
-            body_and_end_on_same_line?(node)
+          node.body && node.multiline? && body_and_end_on_same_line?(node)
         end
 
         def body_and_end_on_same_line?(node)

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

@@ -33,8 +33,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not use trailing `_`s in parallel assignment. ' \
-              'Prefer `%<code>s`.'
+        MSG = 'Do not use trailing `_`s in parallel assignment. Prefer `%<code>s`.'
         UNDERSCORE = '_'
         DISALLOW = %i[lvasgn splat].freeze
         private_constant :DISALLOW
@@ -91,8 +90,7 @@ module RuboCop
         end
 
         def allow_named_underscore_variables
-          @allow_named_underscore_variables ||=
-            cop_config['AllowNamedUnderscoreVariables']
+          @allow_named_underscore_variables ||= cop_config['AllowNamedUnderscoreVariables']
         end
 
         def unneeded_ranges(node)
@@ -121,8 +119,7 @@ module RuboCop
 
           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)
+          range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
         end
 
         def children_offenses(variables)
@@ -147,10 +144,7 @@ module RuboCop
         end
 
         def range_for_parentheses(offense, left)
-          range_between(
-            offense.source_range.begin_pos - 1,
-            left.loc.expression.end_pos - 1
-          )
+          range_between(offense.source_range.begin_pos - 1, left.loc.expression.end_pos - 1)
         end
       end
     end

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

@@ -27,6 +27,71 @@ module RuboCop
       #   class << self
       #     attr_reader :baz
       #   end
+      #
+      # @example ExactNameMatch: true (default)
+      #   # good
+      #   def name
+      #     @other_name
+      #   end
+      #
+      # @example ExactNameMatch: false
+      #   # bad
+      #   def name
+      #     @other_name
+      #   end
+      #
+      # @example AllowPredicates: true (default)
+      #   # good
+      #   def foo?
+      #     @foo
+      #   end
+      #
+      # @example AllowPredicates: false
+      #   # bad
+      #   def foo?
+      #     @foo
+      #   end
+      #
+      #   # good
+      #   attr_reader :foo
+      #
+      # @example AllowDSLWriters: true (default)
+      #   # good
+      #   def on_exception(action)
+      #     @on_exception=action
+      #   end
+      #
+      # @example AllowDSLWriters: false
+      #   # bad
+      #   def on_exception(action)
+      #     @on_exception=action
+      #   end
+      #
+      #   # good
+      #   attr_writer :on_exception
+      #
+      # @example IgnoreClassMethods: false (default)
+      #   # bad
+      #   def self.foo
+      #     @foo
+      #   end
+      #
+      #   # good
+      #   class << self
+      #     attr_reader :foo
+      #   end
+      #
+      # @example IgnoreClassMethods: true
+      #   # good
+      #   def self.foo
+      #     @foo
+      #   end
+      #
+      # @example AllowedMethods: ['allowed_method']
+      #   # good
+      #   def allowed_method
+      #     @foo
+      #   end
       class TrivialAccessors < Base
         include AllowedMethods
         extend AutoCorrector
@@ -107,8 +172,7 @@ module RuboCop
         end
 
         def trivial_reader?(node)
-          looks_like_trivial_reader?(node) &&
-            !allowed_method_name?(node) && !allowed_reader?(node)
+          looks_like_trivial_reader?(node) && !allowed_method_name?(node) && !allowed_reader?(node)
         end
 
         def looks_like_trivial_reader?(node)
@@ -120,6 +184,7 @@ module RuboCop
             !allowed_method_name?(node) && !allowed_writer?(node.method_name)
         end
 
+        # @!method looks_like_trivial_writer?(node)
         def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
           {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
            (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
@@ -127,7 +192,7 @@ module RuboCop
 
         def allowed_method_name?(node)
           allowed_method_names.include?(node.method_name) ||
-            exact_name_match? && !names_match?(node)
+            (exact_name_match? && !names_match?(node))
         end
 
         def allowed_writer?(method_name)
@@ -145,8 +210,7 @@ module RuboCop
         end
 
         def trivial_accessor_kind(node)
-          if trivial_writer?(node) &&
-             !dsl_writer?(node.method_name)
+          if trivial_writer?(node) && !dsl_writer?(node.method_name)
             'writer'
           elsif trivial_reader?(node)
             'reader'

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

@@ -23,8 +23,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
-              'positive case first.'
+        MSG = 'Do not use `unless` with `else`. Rewrite these with the positive case first.'
 
         def on_if(node)
           return unless node.unless? && node.else?

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of logical operators in an `unless` condition.
+      # It discourages such code, as the condition becomes more difficult
+      # to read and understand.
+      #
+      # This cop supports two styles:
+      # - `forbid_mixed_logical_operators` (default)
+      # - `forbid_logical_operators`
+      #
+      # `forbid_mixed_logical_operators` style forbids the use of more than one type
+      # of logical operators. This makes the `unless` condition easier to read
+      # because either all conditions need to be met or any condition need to be met
+      # in order for the expression to be truthy or falsey.
+      #
+      # `forbid_logical_operators` style forbids any use of logical operator.
+      # This makes it even more easy to read the `unless` condition as
+      # there is only one condition in the expression.
+      #
+      # @example EnforcedStyle: forbid_mixed_logical_operators (default)
+      #   # bad
+      #   return unless a || b && c
+      #   return unless a && b || c
+      #   return unless a && b and c
+      #   return unless a || b or c
+      #   return unless a && b or c
+      #   return unless a || b and c
+      #
+      #   # good
+      #   return unless a && b && c
+      #   return unless a || b || c
+      #   return unless a and b and c
+      #   return unless a or b or c
+      #   return unless a?
+      #
+      # @example EnforcedStyle: forbid_logical_operators
+      #   # bad
+      #   return unless a || b
+      #   return unless a && b
+      #   return unless a or b
+      #   return unless a and b
+      #
+      #   # good
+      #   return unless a
+      #   return unless a?
+      class UnlessLogicalOperators < Base
+        include ConfigurableEnforcedStyle
+
+        FORBID_MIXED_LOGICAL_OPERATORS = 'Do not use mixed logical operators in an `unless`.'
+        FORBID_LOGICAL_OPERATORS = 'Do not use any logical operator in an `unless`.'
+
+        # @!method or_with_and?(node)
+        def_node_matcher :or_with_and?, <<~PATTERN
+          (if (or <`and ...> ) ...)
+        PATTERN
+
+        # @!method and_with_or?(node)
+        def_node_matcher :and_with_or?, <<~PATTERN
+          (if (and <`or ...> ) ...)
+        PATTERN
+
+        # @!method logical_operator?(node)
+        def_node_matcher :logical_operator?, <<~PATTERN
+          (if ({and or} ... ) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless node.unless?
+
+          if style == :forbid_mixed_logical_operators && mixed_logical_operator?(node)
+            add_offense(node, message: FORBID_MIXED_LOGICAL_OPERATORS)
+          elsif style == :forbid_logical_operators && logical_operator?(node)
+            add_offense(node, message: FORBID_LOGICAL_OPERATORS)
+          end
+        end
+
+        private
+
+        def mixed_logical_operator?(node)
+          or_with_and?(node) ||
+            and_with_or?(node) ||
+            mixed_precedence_and?(node) ||
+            mixed_precedence_or?(node)
+        end
+
+        def mixed_precedence_and?(node)
+          and_sources = node.condition.each_descendant(:and).map(&:operator)
+          and_sources << node.condition.operator if node.condition.and_type?
+
+          !(and_sources.all?('&&') || and_sources.all?('and'))
+        end
+
+        def mixed_precedence_or?(node)
+          or_sources = node.condition.each_descendant(:or).map(&:operator)
+          or_sources << node.condition.operator if node.condition.or_type?
+
+          !(or_sources.all?('||') || or_sources.all?('or'))
+        end
+      end
+    end
+  end
+end

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

@@ -21,9 +21,10 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
-          '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+              '`%<receiver>s.unpack(%<format>s)%<method>s`.'
         RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
+        # @!method unpack_and_first_element?(node)
         def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
             (send $(send (...) :unpack $(...)) :first)

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

@@ -20,7 +20,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Replace interpolated variable `%<variable>s` ' \
-              'with expression `#{%<variable>s}`.'
+              'with expression `#{%<variable>s}`.' # rubocop:disable Lint/InterpolationCheck
 
         def on_node_with_interpolations(node)
           var_nodes(node.children).each do |var_node|

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

@@ -20,12 +20,14 @@ module RuboCop
       class WhenThen < Base
         extend AutoCorrector
 
-        MSG = 'Do not use `when x;`. Use `when x then` instead.'
+        MSG = 'Do not use `when %<expression>s;`. Use `when %<expression>s then` instead.'
 
         def on_when(node)
           return if node.multiline? || node.then? || !node.body
 
-          add_offense(node.loc.begin) do |corrector|
+          message = format(MSG, expression: node.conditions.map(&:source).join(', '))
+
+          add_offense(node.loc.begin, message: message) do |corrector|
             corrector.replace(node.loc.begin, ' then')
           end
         end

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

@@ -37,8 +37,7 @@ module RuboCop
         include StatementModifier
         extend AutoCorrector
 
-        MSG = 'Favor modifier `%<keyword>s` usage when ' \
-              'having a single-line body.'
+        MSG = 'Favor modifier `%<keyword>s` usage when having a single-line body.'
 
         def on_while(node)
           return unless single_line_as_modifier?(node)

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

@@ -9,6 +9,9 @@ module RuboCop
       # Alternatively, it can check for uses of the %w() syntax, in projects
       # which do not want to include that syntax.
       #
+      # NOTE: When using the `percent` style, %w() arrays containing a space
+      # will be registered as offenses.
+      #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
       # cop. For example, a `MinSize` of `3` will not enforce a style on an
@@ -21,12 +24,18 @@ module RuboCop
       #   # bad
       #   ['foo', 'bar', 'baz']
       #
+      #   # bad (contains spaces)
+      #   %w[foo\ bar baz\ quux]
+      #
       # @example EnforcedStyle: brackets
       #   # good
       #   ['foo', 'bar', 'baz']
       #
       #   # bad
       #   %w[foo bar baz]
+      #
+      #   # good (contains spaces)
+      #   ['foo bar', 'baz quux']
       class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
@@ -35,7 +44,7 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
-        ARRAY_MSG = 'Use `[]` for an array of words.'
+        ARRAY_MSG = 'Use `%<prefer>s` for an array of words.'
 
         class << self
           attr_accessor :largest_brackets
@@ -53,19 +62,27 @@ module RuboCop
 
         private
 
-        def complex_content?(strings)
+        def complex_content?(strings, complex_regex: word_regex)
           strings.any? do |s|
+            next unless s.str_content
+
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
             !string.valid_encoding? ||
-              !word_regex.match?(string) || / /.match?(string)
+              (complex_regex && !complex_regex.match?(string)) ||
+              / /.match?(string)
           end
         end
 
+        def invalid_percent_array_contents?(node)
+          # Disallow %w() arrays that contain invalid encoding or spaces
+          complex_content?(node.values, complex_regex: false)
+        end
+
         def word_regex
           Regexp.new(cop_config['WordRegex'])
         end
 
-        def correct_bracketed(corrector, node)
+        def build_bracketed_array(node)
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
@@ -76,7 +93,7 @@ module RuboCop
             end
           end
 
-          corrector.replace(node, "[#{words.join(', ')}]")
+          "[#{words.join(', ')}]"
         end
       end
     end

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

@@ -7,6 +7,26 @@ module RuboCop
       # i.e. comparison operations where the order of expression is reversed.
       # eg. `5 == x`
       #
+      # @safety
+      #   This cop is unsafe because comparison operators can be defined
+      #   differently on different classes, and are not guaranteed to
+      #   have the same result if reversed.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class MyKlass
+      #     def ==(other)
+      #       true
+      #     end
+      #   end
+      #
+      #   obj = MyKlass.new
+      #   obj == 'string'   #=> true
+      #   'string' == obj   #=> false
+      #   ----
+      #
       # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
       #   # bad
       #   99 == foo
@@ -58,27 +78,20 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
-
-        REVERSE_COMPARISON = {
-          '<' => '>',
-          '<=' => '>=',
-          '>' => '<',
-          '>=' => '<='
-        }.freeze
-
+        REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
         EQUALITY_OPERATORS = %i[== !=].freeze
-
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
-
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+        RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
 
+        # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
           (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
         PATTERN
 
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node) ||
+          return if (equality_only? && non_equality_operator?(node)) ||
                     file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node) do |corrector|
@@ -99,16 +112,15 @@ module RuboCop
         end
 
         def yoda_compatible_condition?(node)
-          node.comparison_method? &&
-            !noncommutative_operator?(node)
+          node.comparison_method? && !noncommutative_operator?(node)
         end
 
         def valid_yoda?(node)
           lhs = node.receiver
           rhs = node.first_argument
 
-          return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal? ||
+          return true if (lhs.literal? && rhs.literal?) ||
+                         (!lhs.literal? && !rhs.literal?) ||
                          interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?
@@ -126,9 +138,7 @@ module RuboCop
         end
 
         def actual_code_range(node)
-          range_between(
-            node.loc.expression.begin_pos, node.loc.expression.end_pos
-          )
+          range_between(node.loc.expression.begin_pos, node.loc.expression.end_pos)
         end
 
         def reverse_comparison(operator)

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

@@ -9,6 +9,12 @@ module RuboCop
       # receiver.length < 1 and receiver.size == 0 that can be
       # replaced by receiver.empty? and !receiver.empty?.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   has an `empty?` method that is defined in terms of `length`. If there
+      #   is a non-standard class that redefines `length` or `empty?`, the cop
+      #   may register a false positive.
+      #
       # @example
       #   # bad
       #   [1, 2, 3].length == 0
@@ -29,8 +35,7 @@ module RuboCop
         extend AutoCorrector
 
         ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
-        NONZERO_MSG = 'Use `!empty?` instead of ' \
-                      '`%<lhs>s %<opr>s %<rhs>s`.'
+        NONZERO_MSG = 'Use `!empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
 
         RESTRICT_ON_SEND = %i[size length].freeze
 
@@ -71,6 +76,7 @@ module RuboCop
           end
         end
 
+        # @!method zero_length_predicate(node)
         def_node_matcher :zero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) $:== (int $0))
            (send (int $0) $:== (send (...) ${:length :size}))
@@ -78,6 +84,7 @@ module RuboCop
            (send (int $1) $:> (send (...) ${:length :size}))}
         PATTERN
 
+        # @!method nonzero_length_predicate(node)
         def_node_matcher :nonzero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
@@ -90,6 +97,7 @@ module RuboCop
           "!#{other_receiver(node).source}.empty?"
         end
 
+        # @!method zero_length_receiver(node)
         def_node_matcher :zero_length_receiver, <<~PATTERN
           {(send (send $_ _) :== (int 0))
            (send (int 0) :== (send $_ _))
@@ -97,6 +105,7 @@ module RuboCop
            (send (int 1) :> (send $_ _))}
         PATTERN
 
+        # @!method other_receiver(node)
         def_node_matcher :other_receiver, <<~PATTERN
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
@@ -105,6 +114,7 @@ module RuboCop
         # Some collection like objects in the Ruby standard library
         # implement `#size`, but not `#empty`. We ignore those to
         # reduce false positives.
+        # @!method non_polymorphic_collection?(node)
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
           {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
            (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}

data/lib/rubocop/cop/team.rb

@@ -107,9 +107,7 @@ module RuboCop
           end
         end
 
-        needed.map do |force_class, joining_cops|
-          force_class.new(joining_cops)
-        end
+        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
       end
 
       def external_dependency_checksum
@@ -247,8 +245,7 @@ module RuboCop
       end
 
       def handle_error(error, location, cop)
-        message = Rainbow("An error occurred while #{cop.name}" \
-                           " cop was inspecting #{location}.").red
+        message = Rainbow("An error occurred while #{cop.name} cop was inspecting #{location}.").red
         @errors << message
         warn message
         if debug?