rubocop 1.9.1 → 1.13.0

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

@@ -64,8 +64,7 @@ module RuboCop
         NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
 
         MSG = '%<command>s parentheses for ternary conditions.'
-        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
-          ' complex conditions.'
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
 
         def on_if(node)
           return if only_closing_parenthesis_is_last_line?(node.condition)
@@ -88,8 +87,7 @@ module RuboCop
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) ||
-                        unsafe_autocorrect?(condition))
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
 
           if parenthesized?(condition)
             correct_parenthesized(corrector, condition)
@@ -127,8 +125,7 @@ module RuboCop
         # Anything that is not a variable, constant, or method/.method call
         # will be counted as a complex expression.
         def non_complex_expression?(condition)
-          NON_COMPLEX_TYPES.include?(condition.type) ||
-            non_complex_send?(condition)
+          NON_COMPLEX_TYPES.include?(condition.type) || non_complex_send?(condition)
         end
 
         def non_complex_send?(node)
@@ -191,6 +188,7 @@ module RuboCop
             (child.send_type? && child.prefix_not?)
         end
 
+        # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
           {($:defined? _ ...)
            (send {_ nil?} $_ _ ...)}

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # This cop checks for trailing code after the method definition.
       #
+      # NOTE: It always accepts endless method definitions that are basically on the same line.
+      #
       # @example
       #   # bad
       #   def some_method; do_stuff
@@ -24,16 +26,18 @@ module RuboCop
       #     b[c: x]
       #   end
       #
+      #   def endless_method = do_stuff
+      #
       class TrailingBodyOnMethodDefinition < Base
         include Alignment
         include TrailingBody
         extend AutoCorrector
 
-        MSG = "Place the first line of a multi-line method definition's " \
-              'body on its own line.'
+        MSG = "Place the first line of a multi-line method definition's body on its own line."
 
         def on_def(node)
           return unless trailing_body?(node)
+          return if node.endless?
 
           add_offense(first_part_of(node.body)) do |corrector|
             LineBreakCorrector.correct_trailing_body(

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

@@ -52,9 +52,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 +76,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

@@ -107,8 +107,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 +119,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 _)))}
@@ -145,8 +145,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

@@ -24,6 +24,7 @@ module RuboCop
           '`%<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

@@ -25,9 +25,7 @@ module RuboCop
         def on_when(node)
           return if node.multiline? || node.then? || !node.body
 
-          add_offense(node.loc.begin) do |corrector|
-            corrector.replace(node.loc.begin, ' then')
-          end
+          add_offense(node.loc.begin) { |corrector| corrector.replace(node.loc.begin, ' then') }
         end
       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

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

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

@@ -59,12 +59,7 @@ module RuboCop
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
 
-        REVERSE_COMPARISON = {
-          '<' => '>',
-          '<=' => '>=',
-          '>' => '<',
-          '>=' => '<='
-        }.freeze
+        REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
 
         EQUALITY_OPERATORS = %i[== !=].freeze
 
@@ -72,6 +67,7 @@ module RuboCop
 
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
 
+        # @!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
@@ -99,8 +95,7 @@ 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)
@@ -126,9 +121,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

@@ -29,8 +29,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 +70,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 +78,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 +91,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 +99,7 @@ module RuboCop
            (send (int 1) :> (send $_ _))}
         PATTERN
 
+        # @!method other_receiver(node)
         def_node_matcher :other_receiver, <<~PATTERN
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
@@ -105,6 +108,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} ...) ...) ...)}