rubocop 0.93.1 → 1.6.1

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

@@ -55,13 +55,18 @@ module RuboCop
           padding = ((' ' * indent_width) + leading_spaces(node)).to_s
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
-          replace_keyword_with_module(corrector, node)
+          replace_namespace_keyword(corrector, node)
           split_on_double_colon(corrector, node, padding)
           add_trailing_end(corrector, node, padding_for_trailing_end)
         end
 
-        def replace_keyword_with_module(corrector, node)
-          corrector.replace(node.loc.keyword, 'module')
+        def replace_namespace_keyword(corrector, node)
+          class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
+            class_node.identifier == node.identifier.namespace
+          end
+          namespace_keyword = class_definition ? 'class' : 'module'
+
+          corrector.replace(node.loc.keyword, namespace_keyword)
         end
 
         def split_on_double_colon(corrector, node, padding)

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where custom logic on rejection nils from arrays
+      # and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
+      #
+      # It is marked as unsafe by default because false positives may occur in the
+      # nil check of block arguments to the receiver object.
+      # For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
+      # and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
+      # when the receiver is a hash object.
+      #
+      # @example
+      #   # bad
+      #   array.reject { |e| e.nil? }
+      #   array.select { |e| !e.nil? }
+      #
+      #   # good
+      #   array.compact
+      #
+      #   # bad
+      #   hash.reject! { |k, v| v.nil? }
+      #   hash.select! { |k, v| !v.nil? }
+      #
+      #   # good
+      #   hash.compact!
+      #
+      class CollectionCompact < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+
+        RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+
+        def_node_matcher :reject_method?, <<~PATTERN
+          (block
+            (send
+              _ ${:reject :reject!})
+            $(args ...)
+            (send
+              $(lvar _) :nil?))
+        PATTERN
+
+        def_node_matcher :select_method?, <<~PATTERN
+          (block
+            (send
+              _ ${:select :select!})
+            $(args ...)
+            (send
+              (send
+                $(lvar _) :nil?) :!))
+        PATTERN
+
+        def on_send(node)
+          block_node = node.parent
+          return unless block_node&.block_type?
+
+          return unless (method_name, args, receiver =
+                           reject_method?(block_node) || select_method?(block_node))
+
+          return unless args.last.source == receiver.source
+
+          range = offense_range(node, block_node)
+          good = good_method_name(method_name)
+          message = format(MSG, good: good, bad: range.source)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, good)
+          end
+        end
+
+        private
+
+        def good_method_name(method_name)
+          if method_name.to_s.end_with?('!')
+            'compact!'
+          else
+            'compact'
+          end
+        end
+
+        def offense_range(send_node, block_node)
+          range_between(send_node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # When using `class_eval` (or other `eval`) with string interpolation,
+      # add a comment block showing its appearance if interpolated (a practice used in Rails code).
+      #
+      # @example
+      #   # from activesupport/lib/active_support/core_ext/string/output_safety.rb
+      #
+      #   # bad
+      #   UNSAFE_STRING_METHODS.each do |unsafe_method|
+      #     if 'String'.respond_to?(unsafe_method)
+      #       class_eval <<-EOT, __FILE__, __LINE__ + 1
+      #         def #{unsafe_method}(*params, &block)
+      #           to_str.#{unsafe_method}(*params, &block)
+      #         end
+      #
+      #         def #{unsafe_method}!(*params)
+      #           @dirty = true
+      #           super
+      #         end
+      #       EOT
+      #     end
+      #   end
+      #
+      #   # good, inline comments in heredoc
+      #   UNSAFE_STRING_METHODS.each do |unsafe_method|
+      #     if 'String'.respond_to?(unsafe_method)
+      #       class_eval <<-EOT, __FILE__, __LINE__ + 1
+      #         def #{unsafe_method}(*params, &block)       # def capitalize(*params, &block)
+      #           to_str.#{unsafe_method}(*params, &block)  #   to_str.capitalize(*params, &block)
+      #         end                                         # end
+      #
+      #         def #{unsafe_method}!(*params)              # def capitalize!(*params)
+      #           @dirty = true                             #   @dirty = true
+      #           super                                     #   super
+      #         end                                         # end
+      #       EOT
+      #     end
+      #   end
+      #
+      #   # good, block comments in heredoc
+      #   class_eval <<-EOT, __FILE__, __LINE__ + 1
+      #     # def capitalize!(*params)
+      #     #   @dirty = true
+      #     #   super
+      #     # end
+      #
+      #     def #{unsafe_method}!(*params)
+      #       @dirty = true
+      #       super
+      #     end
+      #   EOT
+      #
+      #   # good, block comments before heredoc
+      #   class_eval(
+      #     # def capitalize!(*params)
+      #     #   @dirty = true
+      #     #   super
+      #     # end
+      #
+      #     <<-EOT, __FILE__, __LINE__ + 1
+      #       def #{unsafe_method}!(*params)
+      #         @dirty = true
+      #         super
+      #       end
+      #     EOT
+      #   )
+      #
+      #   # bad - interpolated string without comment
+      #   class_eval("def #{unsafe_method}!(*params); end")
+      #
+      #   # good - with inline comment or replace it with block comment using heredoc
+      #   class_eval("def #{unsafe_method}!(*params); end # def capitalize!(*params); end")
+      class DocumentDynamicEvalDefinition < Base
+        BLOCK_COMMENT_REGEXP = /^\s*#(?!{)/.freeze
+        COMMENT_REGEXP = /\s*#(?!{).*/.freeze
+        MSG = 'Add a comment block showing its appearance if interpolated.'
+
+        RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
+
+        def on_send(node)
+          arg_node = node.first_argument
+
+          return unless arg_node&.dstr_type? && interpolated?(arg_node)
+          return if inline_comment_docs?(arg_node) ||
+                    arg_node.heredoc? && comment_block_docs?(arg_node)
+
+          add_offense(node.loc.selector)
+        end
+
+        private
+
+        def interpolated?(arg_node)
+          arg_node.each_child_node(:begin).any?
+        end
+
+        def inline_comment_docs?(node)
+          node.each_child_node(:begin).all? do |begin_node|
+            source_line = processed_source.lines[begin_node.first_line - 1]
+            source_line.match?(COMMENT_REGEXP)
+          end
+        end
+
+        def comment_block_docs?(arg_node)
+          comments = heredoc_comment_blocks(arg_node.loc.heredoc_body.line_span)
+                     .concat(preceding_comment_blocks(arg_node.parent))
+
+          return if comments.none?
+
+          regexp = comment_regexp(arg_node)
+          comments.any? { |comment| regexp.match?(comment) } || regexp.match?(comments.join)
+        end
+
+        def preceding_comment_blocks(node)
+          # Collect comments in the method call, but outside the heredoc
+          comments = processed_source.each_comment_in_lines(node.loc.expression.line_span)
+
+          comments.each_with_object({}) do |comment, hash|
+            merge_adjacent_comments(comment.text, comment.loc.line, hash)
+          end.values
+        end
+
+        def heredoc_comment_blocks(heredoc_body)
+          # Collect comments inside the heredoc
+          line_range = (heredoc_body.begin - 1)..(heredoc_body.end - 1)
+          lines = processed_source.lines[line_range]
+
+          lines.each_with_object({}).with_index(line_range.begin) do |(line, hash), index|
+            merge_adjacent_comments(line, index, hash)
+          end.values
+        end
+
+        def merge_adjacent_comments(line, index, hash)
+          # Combine adjacent comment lines into a single string
+          return unless (line = line.dup.gsub!(BLOCK_COMMENT_REGEXP, ''))
+
+          hash[index] = if hash.keys.last == index - 1
+                          [hash.delete(index - 1), line].join("\n")
+                        else
+                          line
+                        end
+        end
+
+        def comment_regexp(arg_node)
+          # Replace the interpolations with wildcards
+          regexp_parts = arg_node.child_nodes.map do |n|
+            n.begin_type? ? /.+/ : source_to_regexp(n.source)
+          end
+
+          Regexp.new(regexp_parts.join)
+        end
+
+        def source_to_regexp(source)
+          # Get the source in the heredoc being `eval`ed, without any comments
+          # and turn it into a regexp
+          return /\s+/ if source.blank?
+
+          source = source.gsub(COMMENT_REGEXP, '')
+          return if source.blank?
+
+          /\s*#{Regexp.escape(source.strip)}/
+        end
+      end
+    end
+  end
+end

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

@@ -55,6 +55,11 @@ module RuboCop
       #       Public = Class.new
       #     end
       #
+      #     # Macro calls
+      #     module Namespace
+      #       extend Foo
+      #     end
+      #
       class Documentation < Base
         include DocumentationComment
 
@@ -83,15 +88,21 @@ module RuboCop
           return if documentation_comment?(node) || nodoc_comment?(node)
           return if compact_namespace?(node) &&
                     nodoc_comment?(outer_module(node).first)
+          return if macro_only?(body)
 
           add_offense(node.loc.keyword, message: format(MSG, type: type))
         end
 
+        def macro_only?(body)
+          body.respond_to?(:macro?) && body.macro? ||
+            body.respond_to?(:children) && body.children&.all? { |child| macro_only?(child) }
+        end
+
         def namespace?(node)
           return false unless node
 
           if node.begin_type?
-            node.children.all?(&method(:constant_declaration?))
+            node.children.all? { |child| constant_declaration?(child) }
           else
             constant_definition?(node)
           end

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

@@ -34,6 +34,7 @@ module RuboCop
       # this is rarely a problem in practice.
       class DoubleNegation < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Avoid the use of double negation (`!!`).'
         RESTRICT_ON_SEND = %i[!].freeze
@@ -44,7 +45,11 @@ module RuboCop
           return unless double_negative?(node) && node.prefix_bang?
           return if style == :allowed_in_returns && allowed_in_returns?(node)
 
-          add_offense(node.loc.selector)
+          location = node.loc.selector
+          add_offense(location) do |corrector|
+            corrector.remove(location)
+            corrector.insert_after(node, '.nil?')
+          end
         end
 
         private

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

@@ -41,6 +41,8 @@ module RuboCop
       #   a.fdiv(b)
       class FloatDivision < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
         MESSAGES = {
           left_coerce: 'Prefer using `.to_f` on the left side.',
           right_coerce: 'Prefer using `.to_f` on the right side.',
@@ -64,7 +66,20 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node) if offense_condition?(node)
+          return unless offense_condition?(node)
+
+          add_offense(node) do |corrector|
+            case style
+            when :left_coerce, :single_coerce
+              add_to_f_method(corrector, node.receiver)
+              remove_to_f_method(corrector, node.first_argument)
+            when :right_coerce
+              remove_to_f_method(corrector, node.receiver)
+              add_to_f_method(corrector, node.first_argument)
+            when :fdiv
+              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+            end
+          end
         end
 
         private
@@ -87,6 +102,34 @@ module RuboCop
         def message(_node)
           MESSAGES[style]
         end
+
+        def add_to_f_method(corrector, node)
+          corrector.insert_after(node, '.to_f') unless node.send_type? && node.method?(:to_f)
+        end
+
+        def remove_to_f_method(corrector, send_node)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(send_node.loc.selector)
+        end
+
+        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
+          receiver_source = extract_receiver_source(receiver)
+          argument_source = extract_receiver_source(argument)
+
+          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
+            argument_source = "(#{argument_source})"
+          end
+
+          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
+        end
+
+        def extract_receiver_source(node)
+          if node.send_type? && node.method?(:to_f)
+            node.receiver.source
+          else
+            node.source
+          end
+        end
       end
     end
   end

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

@@ -111,15 +111,20 @@ module RuboCop
           format = format_arg.source
 
           args = if param_args.one?
-                   arg = param_args.last
-
-                   arg.hash_type? ? "{ #{arg.source} }" : arg.source
+                   format_single_parameter(param_args.last)
                  else
                    "[#{param_args.map(&:source).join(', ')}]"
                  end
 
           corrector.replace(node, "#{format} % #{args}")
         end
+
+        def format_single_parameter(arg)
+          source = arg.source
+          return "{ #{source} }" if arg.hash_type?
+
+          arg.send_type? && arg.operator_method? && !arg.parenthesized? ? "(#{source})" : source
+        end
       end
     end
   end

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

@@ -37,6 +37,27 @@ module RuboCop
       #
       #   # good
       #   format('%s', 'Hello')
+      #
+      # It is allowed to contain unannotated token
+      # if the number of them is less than or equals to
+      # `MaxUnannotatedPlaceholdersAllowed`.
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 0
+      #
+      #   # bad
+      #   format('%06d', 10)
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%<number>06d', number: 10)
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 1 (default)
+      #
+      #   # bad
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%06d', 10)
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
 
@@ -44,8 +65,12 @@ module RuboCop
           return unless node.value.include?('%')
           return if node.each_ancestor(:xstr, :regexp).any?
 
-          tokens(node) do |detected_style, token_range|
-            if detected_style == style || unannotated_format?(node, detected_style)
+          detections = collect_detections(node)
+          return if detections.empty?
+          return if allowed_unannotated?(detections)
+
+          detections.each do |detected_style, token_range|
+            if detected_style == style
               correct_style_detected
             else
               style_detected(detected_style)
@@ -112,6 +137,26 @@ module RuboCop
             yield(detected_style, token)
           end
         end
+
+        def collect_detections(node)
+          detections = []
+          tokens(node) do |detected_style, token_range|
+            unless unannotated_format?(node, detected_style)
+              detections << [detected_style, token_range]
+            end
+          end
+          detections
+        end
+
+        def allowed_unannotated?(detections)
+          return false if detections.size > max_unannotated_placeholders_allowed
+
+          detections.all? { |detected_style,| detected_style == :unannotated }
+        end
+
+        def max_unannotated_placeholders_allowed
+          cop_config['MaxUnannotatedPlaceholdersAllowed']
+        end
       end
     end
   end