rubocop 0.78.0 → 1.13.0

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
@@ -19,23 +19,19 @@ module RuboCop
       #   else
       #     # do a different thing...
       #   end
-      class UnlessElse < Cop
+      class UnlessElse < Base
         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?
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          body_range = range_between_condition_and_else(node, node.condition)
-          else_range = range_between_else_and_end(node)
+          add_offense(node) do |corrector|
+            body_range = range_between_condition_and_else(node, node.condition)
+            else_range = range_between_else_and_end(node)
 
-          lambda do |corrector|
             corrector.replace(node.loc.keyword, 'if')
             corrector.replace(body_range, else_range.source)
             corrector.replace(else_range, body_range.source)

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

@@ -17,14 +17,14 @@ module RuboCop
       #   # good
       #   'foo'.unpack1('h*')
       #
-      class UnpackFirst < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
+      class UnpackFirst < Base
+        extend AutoCorrector
 
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
           '`%<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)
@@ -39,13 +39,7 @@ module RuboCop
                              receiver: unpack_call.receiver.source,
                              format: unpack_arg.source,
                              method: range.source)
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          unpack_and_first_element?(node) do |unpack_call, _unpack_arg|
-            lambda do |corrector|
+            add_offense(node, message: message) do |corrector|
               corrector.remove(first_element_range(node, unpack_call))
               corrector.replace(unpack_call.loc.selector, 'unpack1')
             end

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

@@ -15,28 +15,25 @@ module RuboCop
       #   "His name is #{$name}"
       #   /check #{$pattern}/
       #   "Let's go to the #{@store}"
-      class VariableInterpolation < Cop
+      class VariableInterpolation < Base
         include Interpolation
+        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|
-            add_offense(var_node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
+            add_offense(var_node) do |corrector|
+              corrector.replace(var_node, "{#{var_node.source}}")
+            end
           end
         end
 
         private
 
-        def message(node)
-          format(MSG, variable: node.source)
+        def message(range)
+          format(MSG, variable: range.source)
         end
 
         def var_nodes(nodes)

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
@@ -17,19 +17,15 @@ module RuboCop
       #   when 1 then 'baz'
       #   when 2 then 'bar'
       #   end
-      class WhenThen < Cop
+      class WhenThen < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `when x;`. Use `when x then` instead.'
 
         def on_when(node)
           return if node.multiline? || node.then? || !node.body
 
-          add_offense(node, location: :begin)
-        end
-
-        def autocorrect(node)
-          lambda 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_do.rb

@@ -28,31 +28,21 @@ module RuboCop
       #   until x.empty?
       #     do_something(x.pop)
       #   end
-      class WhileUntilDo < Cop
+      class WhileUntilDo < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `do` with multi-line `%<keyword>s`.'
 
         def on_while(node)
-          handle(node)
-        end
-
-        def on_until(node)
-          handle(node)
-        end
-
-        def handle(node)
           return unless node.multiline? && node.do?
 
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          do_range = node.condition.source_range.end.join(node.loc.begin)
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            do_range = node.condition.source_range.end.join(node.loc.begin)
 
-          lambda do |corrector|
             corrector.remove(do_range)
           end
         end
+        alias on_until on_while
       end
     end
   end

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

@@ -24,37 +24,29 @@ module RuboCop
       #
       #   # good
       #   x += 1 until x > 10
-      class WhileUntilModifier < Cop
+      #
+      # @example
+      #   # bad
+      #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
+      #
+      #   # good
+      #   while x < 500 # a long comment that makes code too long if it were a single line
+      #     x += 100
+      #   end
+      class WhileUntilModifier < Base
         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)
-          check(node)
-        end
+          return unless single_line_as_modifier?(node)
 
-        def on_until(node)
-          check(node)
-        end
-
-        def autocorrect(node)
-          oneline = "#{node.body.source} #{node.keyword} " \
-                    "#{node.condition.source}"
-
-          lambda do |corrector|
-            corrector.replace(node.source_range, oneline)
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.replace(node, to_modifier_form(node))
           end
         end
-
-        private
-
-        def check(node)
-          return unless node.multiline? && single_line_as_modifier?(node)
-
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
-        end
+        alias on_until on_while
       end
     end
   end

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

@@ -27,11 +27,12 @@ module RuboCop
       #
       #   # bad
       #   %w[foo bar baz]
-      class WordArray < Cop
+      class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentArray
+        extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
         ARRAY_MSG = 'Use `[]` for an array of words.'
@@ -44,36 +45,18 @@ module RuboCop
           if bracketed_array_of?(:str, node)
             return if complex_content?(node.values)
 
-            check_bracketed_array(node)
+            check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
             check_percent_array(node)
           end
         end
 
-        def autocorrect(node)
-          if style == :percent
-            PercentLiteralCorrector
-              .new(@config, @preferred_delimiters)
-              .correct(node, 'w')
-          else
-            correct_bracketed(node)
-          end
-        end
-
         private
 
-        def check_bracketed_array(node)
-          return if allowed_bracket_array?(node)
-
-          array_style_detected(:brackets, node.values.size)
-          add_offense(node) if style == :percent
-        end
-
         def complex_content?(strings)
           strings.any? do |s|
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
-            !string.valid_encoding? ||
-              string !~ word_regex || string =~ / /
+            !string.valid_encoding? || !word_regex.match?(string) || / /.match?(string)
           end
         end
 
@@ -81,7 +64,7 @@ module RuboCop
           Regexp.new(cop_config['WordRegex'])
         end
 
-        def correct_bracketed(node)
+        def correct_bracketed(corrector, node)
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
@@ -92,9 +75,7 @@ module RuboCop
             end
           end
 
-          lambda do |corrector|
-            corrector.replace(node.source_range, "[#{words.join(', ')}]")
-          end
+          corrector.replace(node, "[#{words.join(', ')}]")
         end
       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
@@ -50,32 +52,32 @@ module RuboCop
       #   # good
       #   99 == foo
       #   "bar" != foo
-      class YodaCondition < Cop
+      class YodaCondition < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        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
+
+        # @!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)
-
-          valid_yoda?(node) || add_offense(node)
-        end
+          return if equality_only? && non_equality_operator?(node) ||
+                    file_constant_equal_program_name?(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          valid_yoda?(node) || add_offense(node) do |corrector|
             corrector.replace(actual_code_range(node), corrected_code(node))
           end
         end
@@ -93,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)
@@ -102,7 +103,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
@@ -119,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)
@@ -135,6 +135,20 @@ module RuboCop
         def noncommutative_operator?(node)
           NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
         end
+
+        def source_file_path_constant?(node)
+          node.source == '__FILE__'
+        end
+
+        def program_name?(name)
+          PROGRAM_NAMES.include?(name)
+        end
+
+        def interpolation?(node)
+          return true if node.dstr_type?
+
+          node.regexp_type? && node.interpolation?
+        end
       end
     end
   end