rubocop 0.49.1 → 0.50.0

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

@@ -3,60 +3,72 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of *and* and *or*.
+      # This cop checks for uses of `and` and `or`, and suggests using `&&` and
+      # `|| instead`. It can be configured to check only in conditions, or in
+      # all contexts.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: always (default)
+      #
+      #   # good
+      #   foo.save && return
+      #   if foo && bar
+      #
+      #   # bad
+      #   foo.save and return
+      #   if foo and bar
+      #
+      # @example
+      #
+      #   # EnforcedStyle: conditionals
+      #
+      #   # good
+      #   foo.save && return
+      #   foo.save and return
+      #   if foo && bar
+      #
+      #   # bad
+      #   if foo and bar
       class AndOr < Cop
         include ConfigurableEnforcedStyle
 
         MSG = 'Use `%s` instead of `%s`.'.freeze
 
-        OPS = { 'and' => '&&', 'or' => '||' }.freeze
-
         def on_and(node)
-          process_logical_op(node) if style == :always
-        end
-
-        def on_or(node)
-          process_logical_op(node) if style == :always
+          process_logical_operator(node) if style == :always
         end
+        alias on_or on_and
 
         def on_if(node)
           on_conditionals(node) if style == :conditionals
         end
-
-        def on_while(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_while_post(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_until(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_until_post(node)
-          on_conditionals(node) if style == :conditionals
-        end
+        alias on_while      on_if
+        alias on_while_post on_if
+        alias on_until      on_if
+        alias on_until_post on_if
 
         private
 
         def on_conditionals(node)
           node.condition.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
-            process_logical_op(logical_node)
+            process_logical_operator(logical_node)
           end
         end
 
-        def process_logical_op(node)
+        def process_logical_operator(node)
           return if node.logical_operator?
 
-          add_offense(node, :operator,
-                      format(MSG, node.alternate_operator, node.operator))
+          add_offense(node, :operator)
+        end
+
+        def message(node)
+          format(MSG, node.alternate_operator, node.operator)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            [*node].each do |expr|
+            node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
               elsif expr.return_type?
@@ -73,15 +85,17 @@ module RuboCop
         def correct_send(node, corrector)
           return correct_not(node, node.receiver, corrector) if node.method?(:!)
           return correct_setter(node, corrector) if node.setter_method?
+          return correct_other(node, corrector) if node.comparison_method?
+
           return unless correctable_send?(node)
 
-          corrector.replace(whitespace_before_arg(node), '('.freeze)
-          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+          corrector.replace(whitespace_before_arg(node), '(')
+          corrector.insert_after(node.last_argument.source_range, ')')
         end
 
         def correct_setter(node, corrector)
-          corrector.insert_before(node.receiver.source_range, '('.freeze)
-          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+          corrector.insert_before(node.receiver.source_range, '(')
+          corrector.insert_after(node.last_argument.source_range, ')')
         end
 
         # ! is a special case:
@@ -108,7 +122,7 @@ module RuboCop
         end
 
         def correctable_send?(node)
-          !node.parenthesized? && !node.method?(:[]) && node.arguments?
+          !node.parenthesized? && node.arguments? && !node.method?(:[])
         end
 
         def whitespace_before_arg(node)

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

@@ -13,7 +13,7 @@ module RuboCop
       #   f = File.open('file')
       #
       #   # good
-      #   f = File.open('file') do
+      #   File.open('file') do |f|
       #     ...
       #   end
       class AutoResourceCleanup < Cop

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

@@ -11,7 +11,9 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            add_offense(comment, :expression) if comment.document?
+            next unless comment.document?
+
+            add_offense(comment)
           end
         end
 

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

@@ -111,6 +111,7 @@ module RuboCop
           range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
           when :block
@@ -126,8 +127,8 @@ module RuboCop
           when :pair
             node.each_child_node { |child| get_blocks(child, &block) }
           end
-          nil
         end
+        # rubocop:enable Metrics/CyclimaticComplexity
 
         def proper_block_style?(node)
           return true if ignored_method?(node.method_name)

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

@@ -47,26 +47,37 @@ module RuboCop
         def check_backtick_literal(node)
           return if allowed_backtick_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_PERCENT_X)
+          add_offense(node)
         end
 
         def check_percent_x_literal(node)
           return if allowed_percent_x_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_BACKTICKS)
+          add_offense(node)
+        end
+
+        def message(node)
+          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
         end
 
         def allowed_backtick_literal?(node)
-          style == :backticks && !contains_disallowed_backtick?(node) ||
-            style == :mixed && node.single_line? &&
-              !contains_disallowed_backtick?(node)
+          case style
+          when :backticks
+            !contains_disallowed_backtick?(node)
+          when :mixed
+            node.single_line? && !contains_disallowed_backtick?(node)
+          end
         end
 
         def allowed_percent_x_literal?(node)
-          style == :backticks && contains_disallowed_backtick?(node) ||
-            style == :percent_x ||
-            style == :mixed && node.multiline? ||
-            style == :mixed && contains_disallowed_backtick?(node)
+          case style
+          when :backticks
+            contains_disallowed_backtick?(node)
+          when :mixed
+            node.multiline? || contains_disallowed_backtick?(node)
+          when :percent_x
+            true
+          end
         end
 
         def contains_disallowed_backtick?(node)

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

@@ -6,6 +6,8 @@ module RuboCop
       # Helper module to provide common methods to classes needed for the
       # ConditionalAssignment Cop.
       module ConditionalAssignmentHelper
+        extend NodePattern::Macros
+
         EQUAL = '='.freeze
         END_ALIGNMENT = 'Lint/EndAlignment'.freeze
         ALIGN_WITH = 'EnforcedStyleAlignWith'.freeze
@@ -31,6 +33,7 @@ module RuboCop
           branch.begin_type? ? [*branch].last : branch
         end
 
+        # rubocop:disable Metrics/AbcSize
         def lhs(node)
           case node.type
           when :send
@@ -47,6 +50,7 @@ module RuboCop
             node.source
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indent(cop, source)
           conf = cop.config.for_cop(END_ALIGNMENT)
@@ -219,12 +223,12 @@ module RuboCop
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
-        def_node_matcher :assignment_type?, <<-END
+        def_node_matcher :assignment_type?, <<-PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
             (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
           }
-        END
+        PATTERN
 
         ASSIGNMENT_TYPES.each do |type|
           define_method "on_#{type}" do |node|
@@ -267,21 +271,27 @@ module RuboCop
         private
 
         def check_assignment_to_condition(node)
-          return unless style == :assign_inside_condition
-          return unless assignment_rhs_exist?(node)
+          return unless candidate_node?(node)
+
           ignore_node(node)
 
           assignment = assignment_node(node)
-          return unless condition?(assignment)
-          return if allowed_ternary?(assignment)
+          return unless candidate_condition?(assignment)
 
           _condition, *branches, else_branch = *assignment
-          return unless else_branch # empty else
+
+          return unless else_branch
           return if allowed_single_line?([*branches, else_branch])
 
           add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
         end
 
+        def candidate_node?(node)
+          style == :assign_inside_condition && assignment_rhs_exist?(node)
+        end
+
+        def_node_matcher :candidate_condition?, '[{if case} !#allowed_ternary?]'
+
         def allowed_ternary?(assignment)
           assignment.if_type? && assignment.ternary? && !include_ternary?
         end
@@ -356,7 +366,7 @@ module RuboCop
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def allowed_statements?(branches)
@@ -380,36 +390,20 @@ module RuboCop
 
           assignment = lhs(tail(branches[0]))
 
-          longest_rhs_exceeds_line_limit?(branches, assignment) ||
-            longest_line_exceeds_line_limit?(node, assignment)
-        end
-
-        def longest_rhs_exceeds_line_limit?(branches, assignment)
-          longest_rhs_full_length(branches, assignment) > max_line_length
+          longest_line_exceeds_line_limit?(node, assignment)
         end
 
         def longest_line_exceeds_line_limit?(node, assignment)
           longest_line(node, assignment).length > max_line_length
         end
 
-        def longest_rhs_full_length(branches, assignment)
-          longest_rhs(branches) + indentation_width + assignment.length
-        end
-
         def longest_line(node, assignment)
-          assignment_regex = /#{Regexp.escape(assignment).gsub(' ', '\s*')}/
+          assignment_regex = /\s*#{Regexp.escape(assignment).gsub('\ ', '\s*')}/
           lines = node.source.lines.map do |line|
             line.chomp.sub(assignment_regex, '')
           end
           longest_line = lines.max_by(&:length)
-          longest_line + assignment
-        end
-
-        def longest_rhs(branches)
-          line_lengths = branches.flat_map do |branch|
-            branch.children.last.source.split("\n").map(&:length)
-          end
-          line_lengths.max
+          assignment + longest_line
         end
 
         def line_length_cop_enabled?
@@ -475,7 +469,15 @@ module RuboCop
 
         def replace_branch_assignment(corrector, branch)
           _variable, *_operator, assignment = *branch
-          corrector.replace(branch.source_range, assignment.source)
+          source = assignment.source
+
+          replacement = if assignment.array_type? && !assignment.bracketed?
+                          "[#{source}]"
+                        else
+                          source
+                        end
+
+          corrector.replace(branch.source_range, replacement)
         end
 
         def correct_branches(corrector, branches)

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

@@ -16,14 +16,21 @@ module RuboCop
       # an offense is reported.
       #
       class Copyright < Cop
+        MSG = 'Include a copyright notice matching /%s/ before ' \
+              'any code.'.freeze
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in' \
                                     'your RuboCop config'.freeze
 
-        def message
-          "Include a copyright notice matching /#{notice}/" \
-          'before any code.'
+        def investigate(processed_source)
+          return if notice.empty?
+          return if notice_found?(processed_source)
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(insert_notice_before(processed_source),
+                      range, MSG % notice)
         end
 
+        private
+
         def notice
           cop_config['Notice']
         end
@@ -32,13 +39,6 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
-        def investigate(processed_source)
-          return if notice.empty?
-          return if notice_found?(processed_source)
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(insert_notice_before(processed_source), range, message)
-        end
-
         def insert_notice_before(processed_source)
           token_index = 0
           token_index += 1 if shebang_token?(processed_source, token_index)

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

@@ -7,17 +7,18 @@ module RuboCop
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
       class DefWithParentheses < Cop
-        include OnMethodDef
-
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'.freeze
 
-        def on_method_def(node, _method_name, args, _body)
+        def on_def(node)
           return if node.single_line?
-          return unless args.children.empty? && args.loc.begin
+          return unless !node.arguments? && node.arguments.loc.begin
 
-          add_offense(args, :begin)
+          add_offense(node.arguments, :begin)
         end
+        alias on_defs on_def
+
+        private
 
         def autocorrect(node)
           lambda do |corrector|

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where the `#__dir__` method can replace more
+      # complex constructs to retrieve a canonicalized absolute path to the
+      # current file.
+      #
+      # @example
+      #   # bad
+      #   path = File.expand_path(File.dirname(__FILE__))
+      #
+      #   # bad
+      #   path = File.dirname(File.realpath(__FILE__))
+      #
+      #   # good
+      #   path = __dir__
+      class Dir < Cop
+        extend TargetRubyVersion
+
+        MSG = 'Use `__dir__` to get an absolute path to the current ' \
+              "file's directory.".freeze
+
+        def_node_matcher :dir_replacement?, <<-PATTERN
+          {(send (const nil :File) :expand_path (send (const nil :File) :dirname  #file_keyword?))
+           (send (const nil :File) :dirname     (send (const nil :File) :realpath #file_keyword?))}
+        PATTERN
+
+        minimum_target_ruby_version 2.0
+
+        def on_send(node)
+          dir_replacement?(node) do
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, '__dir__')
+          end
+        end
+
+        def file_keyword?(node)
+          node.str_type? && node.source_range.is?('__FILE__')
+        end
+      end
+    end
+  end
+end