rubocop 0.75.1 → 0.76.0

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

@@ -5,27 +5,39 @@ module RuboCop
     module Style
       # This cop checks for non-nil checks, which are usually redundant.
       #
-      # @example
+      # With `IncludeSemanticChanges` set to `false` by default, this cop
+      # does not report offenses for `!x.nil?` and does no changes that might
+      # change behavior.
+      #
+      # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
+      # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
+      # is **usually** OK, but might change behavior.
       #
+      # @example
       #   # bad
       #   if x != nil
       #   end
       #
-      #   # good (when not allowing semantic changes)
-      #   # bad (when allowing semantic changes)
-      #   if !x.nil?
-      #   end
-      #
-      #   # good (when allowing semantic changes)
+      #   # good
       #   if x
       #   end
       #
-      # Non-nil checks are allowed if they are the final nodes of predicate.
-      #
+      #   # Non-nil checks are allowed if they are the final nodes of predicate.
       #   # good
       #   def signed_in?
       #     !current_user.nil?
       #   end
+      #
+      # @example IncludeSemanticChanges: false (default)
+      #   # good
+      #   if !x.nil?
+      #   end
+      #
+      # @example IncludeSemanticChanges: true
+      #   # bad
+      #   if !x.nil?
+      #   end
+      #
       class NonNilCheck < Cop
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'

data/lib/rubocop/cop/style/{unneeded_capital_w.rb → redundant_capital_w.rb}

@@ -14,7 +14,7 @@ module RuboCop
       #   %w/swim run bike/
       #   %w[shirt pants shoes]
       #   %W(apple #{fruit} grape)
-      class UnneededCapitalW < Cop
+      class RedundantCapitalW < Cop
         include PercentLiteral
 
         MSG = 'Do not use `%W` unless interpolation is needed. ' \

data/lib/rubocop/cop/style/{unneeded_condition.rb → redundant_condition.rb}

@@ -30,11 +30,11 @@ module RuboCop
       #     c
       #   end
       #
-      class UnneededCondition < Cop
+      class RedundantCondition < Cop
         include RangeHelp
 
         MSG = 'Use double pipes `||` instead.'
-        UNNEEDED_CONDITION = 'This condition is not needed.'
+        REDUNDANT_CONDITION = 'This condition is not needed.'
 
         def on_if(node)
           return if node.elsif_conditional?
@@ -61,7 +61,7 @@ module RuboCop
 
         def message(node)
           if node.modifier_form? || !node.else_branch
-            UNNEEDED_CONDITION
+            REDUNDANT_CONDITION
           else
             MSG
           end

data/lib/rubocop/cop/style/{unneeded_interpolation.rb → redundant_interpolation.rb}

@@ -15,7 +15,7 @@ module RuboCop
       #
       #   # good if @var is already a String
       #   @var
-      class UnneededInterpolation < Cop
+      class RedundantInterpolation < Cop
         include PercentLiteral
 
         MSG = 'Prefer `to_s` over string interpolation.'

data/lib/rubocop/cop/style/{unneeded_percent_q.rb → redundant_percent_q.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   time = "8 o'clock"
       #   question = '"What did you say?"'
       #
-      class UnneededPercentQ < Cop
+      class RedundantPercentQ < Cop
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'
         DYNAMIC_MSG = ', or for dynamic strings that contain ' \

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

@@ -60,27 +60,38 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def autocorrect(node)
           lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
             end
-
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless return_value.braces?
-            end
-            return_kw = range_with_surrounding_space(range: node.loc.keyword,
-                                                     side: :right)
-            corrector.remove(return_kw)
           end
         end
 
         private
 
+        def correct_without_arguments(return_node, corrector)
+          corrector.replace(return_node.source_range, 'nil')
+        end
+
+        def correct_with_arguments(return_node, corrector)
+          if return_node.arguments.size > 1
+            add_brackets(corrector, return_node)
+          elsif hash_without_braces?(return_node.first_argument)
+            add_braces(corrector, return_node.first_argument)
+          end
+
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
+                                                 side: :right)
+          corrector.remove(keyword)
+        end
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
         def add_brackets(corrector, node)
           kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '[')
@@ -93,13 +104,6 @@ module RuboCop
           corrector.insert_after(kids.last, '}')
         end
 
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
-
-          !args.first.begin_type? || !args.first.children.empty?
-        end
-
         # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node

data/lib/rubocop/cop/style/{unneeded_sort.rb → redundant_sort.rb}

@@ -49,13 +49,13 @@ module RuboCop
       #   # good
       #   arr.max_by(&:foo)
       #
-      class UnneededSort < Cop
+      class RedundantSort < Cop
         include RangeHelp
 
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
-        def_node_matcher :unneeded_sort?, <<~MATCHER
+        def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
             (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
@@ -72,7 +72,7 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          unneeded_sort?(node) do |sort_node, sorter, accessor|
+          redundant_sort?(node) do |sort_node, sorter, accessor|
             range = range_between(
               sort_node.loc.selector.begin_pos,
               node.loc.expression.end_pos
@@ -87,7 +87,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          sort_node, sorter, accessor = unneeded_sort?(node)
+          sort_node, sorter, accessor = redundant_sort?(node)
 
           lambda do |corrector|
             # Remove accessor, e.g. `first` or `[-1]`.

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

@@ -112,9 +112,8 @@ module RuboCop
         end
 
         def autocorrect(node)
-          _check, body, = node.node_parts
-          _checked_variable, matching_receiver, = extract_parts(node)
-          method_call, = matching_receiver.parent
+          body = node.node_parts[1]
+          method_call = method_call(node)
 
           lambda do |corrector|
             corrector.remove(begin_range(node, body))
@@ -129,25 +128,29 @@ module RuboCop
         private
 
         def handle_comments(corrector, node, method_call)
-          return if processed_source.comments.empty?
+          comments = comments(node)
+          return if comments.empty?
 
           corrector.insert_before(method_call.loc.expression,
-                                  "#{comments(node).join("\n")}\n")
+                                  "#{comments.map(&:text).join("\n")}\n")
         end
 
         def comments(node)
-          comments = processed_source.comments.select do |comment|
-            comment.loc.first_line >= node.loc.first_line &&
-              comment.loc.last_line <= node.loc.last_line
+          processed_source.comments.select do |comment|
+            comment.loc.first_line > node.loc.first_line &&
+              comment.loc.last_line < node.loc.last_line
           end
-
-          comments.map(&:text)
         end
 
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end
 
+        def method_call(node)
+          _checked_variable, matching_receiver, = extract_parts(node)
+          matching_receiver.parent
+        end
+
         def extract_parts(node)
           case node.type
           when :if

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

@@ -47,8 +47,8 @@ module RuboCop
           return if exprs.size < 2
 
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.source_range.line }
-          lines = exprs_lines.group_by { |i| i }
+          exprs_lines = exprs.map(&:first_line)
+          lines = exprs_lines.group_by(&:itself)
 
           lines.each do |line, expr_on_line|
             # Every line with more than one expression on it is a

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

@@ -160,17 +160,15 @@ module RuboCop
         end
 
         def format_message(english, regular, global)
-          if !regular.empty? && !english.empty?
+          if regular.empty?
+            format(MSG_ENGLISH, prefer: format_list(english), global: global)
+          elsif english.empty?
+            format(MSG_REGULAR, prefer: format_list(regular), global: global)
+          else
             format(MSG_BOTH,
                    prefer: format_list(english),
                    regular: format_list(regular),
                    global: global)
-          elsif !regular.empty?
-            format(MSG_REGULAR, prefer: format_list(regular), global: global)
-          elsif !english.empty?
-            format(MSG_ENGLISH, prefer: format_list(english), global: global)
-          else
-            raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
           end
         end
 

data/lib/rubocop/cop/util.rb

@@ -9,7 +9,7 @@ module RuboCop
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
       LITERAL_REGEX =
-        /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/.freeze
+        %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
 
       module_function
 

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

@@ -44,15 +44,15 @@ module RuboCop
           attr_reader :begin_pos, :end_pos
           attr_reader :flags, :width, :precision, :name, :type
 
-          def initialize(string, **opts)
-            @source = string
-            @begin_pos = opts[:begin_pos]
-            @end_pos = opts[:end_pos]
-            @flags = opts[:flags]
-            @width = opts[:width]
-            @precision = opts[:precision]
-            @name = opts[:name]
-            @type = opts[:type]
+          def initialize(match)
+            @source = match[0]
+            @begin_pos = match.begin(0)
+            @end_pos = match.end(0)
+            @flags = match[:flags].to_s + match[:more_flags].to_s
+            @width = match[:width]
+            @precision = match[:precision]
+            @name = match[:name]
+            @type = match[:type]
           end
 
           def percent?
@@ -109,16 +109,8 @@ module RuboCop
 
         def parse
           @source.to_enum(:scan, SEQUENCE).map do
-            match = Regexp.last_match
             FormatSequence.new(
-              match[0],
-              begin_pos: match.begin(0),
-              end_pos: match.end(0),
-              flags: match[:flags].to_s + match[:more_flags].to_s,
-              width: match[:width],
-              precision: match[:precision],
-              name: match[:name],
-              type: match[:type]
+              Regexp.last_match
             )
           end
         end

data/lib/rubocop/cop/variable_force.rb

@@ -284,11 +284,7 @@ module RuboCop
       def process_scope(node)
         if TWISTED_SCOPE_TYPES.include?(node.type)
           # See the comment at the end of file for this behavior.
-          twisted_nodes = [node.children[0]]
-          twisted_nodes << node.children[1] if node.class_type?
-          twisted_nodes.compact!
-
-          twisted_nodes.each do |twisted_node|
+          twisted_nodes(node).each do |twisted_node|
             process_node(twisted_node)
             scanned_nodes << twisted_node
           end
@@ -298,6 +294,12 @@ module RuboCop
         skip_children!
       end
 
+      def twisted_nodes(node)
+        twisted_nodes = [node.children[0]]
+        twisted_nodes << node.children[1] if node.class_type?
+        twisted_nodes.compact
+      end
+
       def process_send(node)
         _receiver, method_name, args = *node
         return unless method_name == :binding

data/lib/rubocop/node_pattern.rb

@@ -429,12 +429,13 @@ module RuboCop
         [0..Float::INFINITY, 'true']
       end
 
+      # rubocop:disable Metrics/AbcSize
       # rubocop:disable Metrics/MethodLength
       def compile_any_order(capture_all = nil)
         rest = capture_rest = nil
         patterns = []
         with_temp_variables do |child, matched|
-          tokens_until('>', 'any child').each do
+          tokens_until('>', 'any child') do
             fail_due_to 'ellipsis must be at the end of <>' if rest
             token = tokens.shift
             case token
@@ -448,6 +449,7 @@ module RuboCop
         end
       end
       # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
 
       def insure_same_captures(enum, what)
         return to_enum __method__, enum, what unless block_given?

data/lib/rubocop/options.rb

@@ -255,11 +255,17 @@ module RuboCop
       @options = options
     end
 
+    def validate_cop_options
+      %i[only except].each do |opt|
+        OptionsValidator.validate_cop_list(@options[opt])
+      end
+    end
+
     # rubocop:disable Metrics/AbcSize
     def validate_compatibility # rubocop:disable Metrics/MethodLength
-      if only_includes_unneeded_disable?
-        raise OptionArgumentError, 'Lint/UnneededCopDisableDirective can not ' \
-                                   'be used with --only.'
+      if only_includes_redundant_disable?
+        raise OptionArgumentError, 'Lint/RedundantCopDisableDirective can ' \
+                                   'not be used with --only.'
       end
       if except_syntax?
         raise OptionArgumentError, 'Syntax checking can not be turned off.'
@@ -332,10 +338,10 @@ module RuboCop
       end
     end
 
-    def only_includes_unneeded_disable?
+    def only_includes_redundant_disable?
       @options.key?(:only) &&
-        (@options[:only] & %w[Lint/UnneededCopDisableDirective
-                              UnneededCopDisableDirective]).any?
+        (@options[:only] & %w[Lint/RedundantCopDisableDirective
+                              RedundantCopDisableDirective]).any?
     end
 
     def display_only_fail_level_offenses_with_autocorrect?

data/lib/rubocop/result_cache.rb

@@ -100,7 +100,7 @@ module RuboCop
 
       begin
         FileUtils.mkdir_p(dir)
-      rescue Errno::EACCES => e
+      rescue Errno::EACCES, Errno::EROFS => e
         warn "Couldn't create cache directory. Continuing without cache."\
              "\n  #{e.message}"
         return

data/lib/rubocop/runner.rb

@@ -104,25 +104,20 @@ module RuboCop
     end
 
     def process_file(file)
-      puts "Scanning #{file}" if @options[:debug]
       file_started(file)
-
       offenses = file_offenses(file)
-      if @options[:display_only_fail_level_offenses]
-        offenses = offenses.select { |o| considered_failure?(o) }
-      end
-      formatter_set.file_finished(file, offenses)
-      offenses
     rescue InfiniteCorrectionLoop => e
-      formatter_set.file_finished(file, e.offenses.compact.sort.freeze)
+      offenses = e.offenses.compact.sort.freeze
       raise
+    ensure
+      file_finished(file, offenses || [])
     end
 
     def file_offenses(file)
       file_offense_cache(file) do
         source = get_processed_source(file)
         source, offenses = do_inspection_loop(file, source)
-        add_unneeded_disables(file, offenses.compact.sort, source)
+        add_redundant_disables(file, offenses.compact.sort, source)
       end
     end
 
@@ -146,33 +141,37 @@ module RuboCop
       offenses
     end
 
-    def add_unneeded_disables(file, offenses, source)
-      if check_for_unneeded_disables?(source)
-        config = @config_store.for(file)
-        if config.for_cop(Cop::Lint::UnneededCopDisableDirective)
-                 .fetch('Enabled')
-          cop = Cop::Lint::UnneededCopDisableDirective.new(config, @options)
-          if cop.relevant_file?(file)
-            cop.check(offenses, source.disabled_line_ranges, source.comments)
-            offenses += cop.offenses
-            offenses += autocorrect_unneeded_disables(file, source, cop,
-                                                      offenses)
-          end
+    def add_redundant_disables(file, offenses, source)
+      if check_for_redundant_disables?(source)
+        redundant_cop_disable_directive(file) do |cop|
+          cop.check(offenses, source.disabled_line_ranges, source.comments)
+          offenses += cop.offenses
+          offenses += autocorrect_redundant_disables(file, source, cop,
+                                                     offenses)
         end
       end
 
       offenses.sort.reject(&:disabled?).freeze
     end
 
-    def check_for_unneeded_disables?(source)
+    def check_for_redundant_disables?(source)
       !source.disabled_line_ranges.empty? && !filtered_run?
     end
 
+    def redundant_cop_disable_directive(file)
+      config = @config_store.for(file)
+      if config.for_cop(Cop::Lint::RedundantCopDisableDirective)
+               .fetch('Enabled')
+        cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
+        yield cop if cop.relevant_file?(file)
+      end
+    end
+
     def filtered_run?
       @options[:except] || @options[:only]
     end
 
-    def autocorrect_unneeded_disables(file, source, cop, offenses)
+    def autocorrect_redundant_disables(file, source, cop, offenses)
       cop.processed_source = source
 
       team = Cop::Team.new(RuboCop::Cop::Registry.new, nil, @options)
@@ -180,7 +179,7 @@ module RuboCop
 
       return [] unless team.updated_source_file?
 
-      # Do one extra inspection loop if any unneeded disables were
+      # Do one extra inspection loop if any redundant disables were
       # removed. This is done in order to find rubocop:enable directives that
       # have now become useless.
       _source, new_offenses = do_inspection_loop(file,
@@ -189,11 +188,19 @@ module RuboCop
     end
 
     def file_started(file)
+      puts "Scanning #{file}" if @options[:debug]
       formatter_set.file_started(file,
                                  cli_options: @options,
                                  config_store: @config_store)
     end
 
+    def file_finished(file, offenses)
+      if @options[:display_only_fail_level_offenses]
+        offenses = offenses.select { |o| considered_failure?(o) }
+      end
+      formatter_set.file_finished(file, offenses)
+    end
+
     def cached_run?
       @cached_run ||=
         (@options[:cache] == 'true' ||
@@ -291,9 +298,7 @@ module RuboCop
       @mobilized_cop_classes[config.object_id] ||= begin
         cop_classes = Cop::Cop.all
 
-        %i[only except].each do |opt|
-          OptionsValidator.validate_cop_list(@options[opt])
-        end
+        OptionsValidator.new(@options).validate_cop_options
 
         if @options[:only]
           cop_classes.select! { |c| c.match?(@options[:only]) }