rubocop 0.75.1 → 0.93.1

data/lib/rubocop/cop/util.rb

@@ -9,12 +9,18 @@ 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
 
+      # This is a bad API
       def comment_line?(line_source)
-        line_source =~ /^\s*#/
+        /^\s*#/.match?(line_source)
+      end
+
+      # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
+      def comment_lines?(node)
+        processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
 
       def line_range(node)
@@ -26,6 +32,26 @@ module RuboCop
           node.loc.end.is?(')')
       end
 
+      def add_parentheses(node, corrector)
+        if node.arguments.empty?
+          corrector.insert_after(node, '()')
+        else
+          corrector.replace(args_begin(node), '(')
+          corrector.insert_after(args_end(node), ')')
+        end
+      end
+
+      def args_begin(node)
+        loc = node.loc
+        selector =
+          node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+        selector.end.resize(1)
+      end
+
+      def args_end(node)
+        node.loc.expression.end
+      end
+
       def on_node(syms, sexp, excludes = [], &block)
         return to_enum(:on_node, syms, sexp, excludes) unless block_given?
 
@@ -64,7 +90,7 @@ module RuboCop
 
         # Regex matches IF there is a ' or there is a \\ in the string that is
         # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-        string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
+        /'|(?<! \\) \\{2}* \\ (?![\\"])/x.match?(string)
       end
 
       def needs_escaping?(string)
@@ -84,7 +110,7 @@ module RuboCop
       end
 
       def trim_string_interporation_escape_character(str)
-        str.gsub(/\\\#{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
+        str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       end
 
       def interpret_string_escapes(string)
@@ -103,19 +129,6 @@ module RuboCop
           .sub('Style', 'Styles')
       end
 
-      def tokens(node)
-        @tokens ||= {}
-        return @tokens[node.object_id] if @tokens[node.object_id]
-
-        source_range = node.source_range
-        begin_pos = source_range.begin_pos
-        end_pos = source_range.end_pos
-
-        @tokens[node.object_id] = processed_source.tokens.select do |token|
-          token.end_pos <= end_pos && token.begin_pos >= begin_pos
-        end
-      end
-
       private
 
       def compatible_external_encoding_for?(src)

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

@@ -41,18 +41,17 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          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]
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :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?
@@ -97,6 +96,10 @@ module RuboCop
           @format_sequences ||= parse
         end
 
+        def valid?
+          !mixed_formats?
+        end
+
         def named_interpolation?
           format_sequences.any?(&:name)
         end
@@ -108,19 +111,23 @@ module RuboCop
         private
 
         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]
-            )
+          matches = []
+          @source.scan(SEQUENCE) { matches << FormatSequence.new(Regexp.last_match) }
+          matches
+        end
+
+        def mixed_formats?
+          formats = format_sequences.reject(&:percent?).map do |seq|
+            if seq.name
+              :named
+            elsif seq.max_digit_dollar_num
+              :numbered
+            else
+              :unnumbered
+            end
           end
+
+          formats.uniq.size > 1
         end
       end
     end

data/lib/rubocop/cop/variable_force.rb

@@ -22,6 +22,8 @@ module RuboCop
     #
     #     def after_declaring_variable(variable, variable_table)
     #     end
+    #
+    # @api private
     class VariableForce < Force # rubocop:disable Metrics/ClassLength
       VARIABLE_ASSIGNMENT_TYPE = :lvasgn
       REGEXP_NAMED_CAPTURE_TYPE = :match_with_lvasgn
@@ -152,9 +154,7 @@ module RuboCop
       def process_variable_assignment(node)
         name = node.children.first
 
-        unless variable_table.variable_exist?(name)
-          variable_table.declare_variable(name, node)
-        end
+        variable_table.declare_variable(name, node) unless variable_table.variable_exist?(name)
 
         # Need to scan rhs before assignment so that we can mark previous
         # assignments as referenced if rhs has referencing to the variable
@@ -190,13 +190,15 @@ module RuboCop
       end
 
       def regexp_captured_names(node)
-        regexp_string = node.children[0].children[0] || ''
+        regexp_string = node.children.select(&:str_type?).map do |child|
+          child.children.first
+        end.join || ''
+
         regexp = Regexp.new(regexp_string)
 
         regexp.named_captures.keys
       end
 
-      # rubocop:disable Metrics/AbcSize
       def process_variable_operator_assignment(node)
         if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
           asgn_node, rhs_node = *node
@@ -208,9 +210,7 @@ module RuboCop
 
         name = asgn_node.children.first
 
-        unless variable_table.variable_exist?(name)
-          variable_table.declare_variable(name, asgn_node)
-        end
+        variable_table.declare_variable(name, asgn_node) unless variable_table.variable_exist?(name)
 
         # The following statements:
         #
@@ -233,7 +233,6 @@ module RuboCop
 
         skip_children!
       end
-      # rubocop:enable Metrics/AbcSize
 
       def process_variable_multiple_assignment(node)
         lhs_node, rhs_node = *node
@@ -284,11 +283,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 +293,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
@@ -364,9 +365,7 @@ module RuboCop
           AssignmentReference.new(node)
         when *OPERATOR_ASSIGNMENT_TYPES
           asgn_node = node.children.first
-          if asgn_node.lvasgn_type?
-            VariableReference.new(asgn_node.children.first)
-          end
+          VariableReference.new(asgn_node.children.first) if asgn_node.lvasgn_type?
         end
       end
 

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -10,6 +10,7 @@ module RuboCop
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
         attr_reader :node, :variable, :referenced, :references
+
         alias referenced? referenced
 
         def initialize(node, variable)

data/lib/rubocop/cop/variable_force/branch.rb

@@ -20,8 +20,6 @@ module RuboCop
           nil
         end
 
-        # rubocop:disable Metrics/BlockLength
-
         # Abstract base class for branch classes.
         # A branch represents a conditional branch in a scope.
         #
@@ -42,13 +40,12 @@ module RuboCop
         #     do_something     # no branch
         #   end
         Base = Struct.new(:child_node, :scope) do
-          # rubocop:enable Metrics/BlockLength
-
           def self.classes
             @classes ||= []
           end
 
           def self.inherited(subclass)
+            super
             classes << subclass
           end
 
@@ -81,9 +78,7 @@ module RuboCop
           end
 
           def each_ancestor(include_self: false, &block)
-            unless block_given?
-              return to_enum(__method__, include_self: include_self)
-            end
+            return to_enum(__method__, include_self: include_self) unless block_given?
 
             yield self if include_self
             scan_ancestors(&block)

data/lib/rubocop/cop/variable_force/scope.rb

@@ -16,6 +16,7 @@ module RuboCop
         }.freeze
 
         attr_reader :node, :variables, :naked_top_level
+
         alias naked_top_level? naked_top_level
 
         def initialize(node)

data/lib/rubocop/cop/variable_force/variable.rb

@@ -11,6 +11,7 @@ module RuboCop
 
         attr_reader :name, :declaration_node, :scope,
                     :assignments, :references, :captured_by_block
+
         alias captured_by_block? captured_by_block
 
         def initialize(name, declaration_node, scope)
@@ -37,18 +38,16 @@ module RuboCop
           !@references.empty?
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
-          consumed_branches = Set.new
+          consumed_branches = nil
 
           @assignments.reverse_each do |assignment|
-            next if consumed_branches.include?(assignment.branch)
+            next if consumed_branches&.include?(assignment.branch)
 
-            unless assignment.run_exclusively_with?(reference)
-              assignment.reference!(node)
-            end
+            assignment.reference!(node) unless assignment.run_exclusively_with?(reference)
 
             # Modifier if/unless conditions are special. Assignments made in
             # them do not put the assigned variable in scope to the left of the
@@ -60,11 +59,11 @@ module RuboCop
             break if !assignment.branch || assignment.branch == reference.branch
 
             unless assignment.branch.may_run_incompletely?
-              consumed_branches << assignment.branch
+              (consumed_branches ||= Set.new) << assignment.branch
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def in_modifier_if?(assignment)
           parent = assignment.node.parent

data/lib/rubocop/cops_documentation_generator.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+# Class for generating documentation of all cops departments
+# @api private
+class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
+  include ::RuboCop::Cop::Documentation
+  # This class will only generate documentation for cops that belong to one of
+  # the departments given in the `departments` array. E.g. if we only wanted
+  # documentation for Lint cops:
+  #
+  #   CopsDocumentationGenerator.new(departments: ['Lint']).call
+  #
+  def initialize(departments: [])
+    @departments = departments.map(&:to_sym).sort!
+    @cops = RuboCop::Cop::Registry.global
+    @config = RuboCop::ConfigLoader.default_configuration
+  end
+
+  def call
+    YARD::Registry.load!
+    departments.each do |department|
+      print_cops_of_department(department)
+    end
+
+    print_table_of_contents
+  ensure
+    RuboCop::ConfigLoader.default_configuration = nil
+  end
+
+  private
+
+  attr_reader :departments, :cops, :config
+
+  def cops_of_department(department)
+    cops.with_department(department).sort!
+  end
+
+  def cops_body(cop, description, examples_objects, pars)
+    content = h2(cop.cop_name)
+    content << required_ruby_version(cop)
+    content << properties(cop)
+    content << "#{description}\n"
+    content << examples(examples_objects) if examples_objects.count.positive?
+    content << configurations(pars)
+    content << references(cop)
+    content
+  end
+
+  def examples(examples_object)
+    examples_object.each_with_object(h3('Examples').dup) do |example, content|
+      content << "\n" unless content.end_with?("\n\n")
+      content << h4(example.name) unless example.name == ''
+      content << code_example(example)
+    end
+  end
+
+  def required_ruby_version(cop)
+    return '' unless cop.respond_to?(:required_minimum_ruby_version)
+
+    "NOTE: Required Ruby version: #{cop.required_minimum_ruby_version}\n\n"
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def properties(cop)
+    header = [
+      'Enabled by default', 'Safe', 'Supports autocorrection', 'VersionAdded',
+      'VersionChanged'
+    ]
+    autocorrect = if cop.support_autocorrect?
+                    "Yes#{' (Unsafe)' unless cop.new(config).safe_autocorrect?}"
+                  else
+                    'No'
+                  end
+    cop_config = config.for_cop(cop)
+    content = [[
+      cop_status(cop_config.fetch('Enabled')),
+      cop_config.fetch('Safe', true) ? 'Yes' : 'No',
+      autocorrect,
+      cop_config.fetch('VersionAdded', '-'),
+      cop_config.fetch('VersionChanged', '-')
+    ]]
+    "#{to_table(header, content)}\n"
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def h2(title)
+    content = +"\n"
+    content << "== #{title}\n"
+    content << "\n"
+    content
+  end
+
+  def h3(title)
+    content = +"\n"
+    content << "=== #{title}\n"
+    content << "\n"
+    content
+  end
+
+  def h4(title)
+    content = +"==== #{title}\n"
+    content << "\n"
+    content
+  end
+
+  def code_example(ruby_code)
+    content = +"[source,ruby]\n----\n"
+    content << ruby_code.text.gsub('@good', '# good')
+                        .gsub('@bad', '# bad').strip
+    content << "\n----\n"
+    content
+  end
+
+  def configurations(pars)
+    return '' if pars.empty?
+
+    header = ['Name', 'Default value', 'Configurable values']
+    configs = pars
+              .each_key
+              .reject { |key| key.start_with?('Supported') }
+              .reject { |key| key.start_with?('AllowMultipleStyles') }
+    content = configs.map do |name|
+      configurable = configurable_values(pars, name)
+      default = format_table_value(pars[name])
+      [name, default, configurable]
+    end
+
+    h3('Configurable attributes') + to_table(header, content)
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+  def configurable_values(pars, name)
+    case name
+    when /^Enforced/
+      supported_style_name = RuboCop::Cop::Util.to_supported_styles(name)
+      format_table_value(pars[supported_style_name])
+    when 'IndentationWidth'
+      'Integer'
+    when 'Database'
+      format_table_value(pars['SupportedDatabases'])
+    else
+      case pars[name]
+      when String
+        'String'
+      when Integer
+        'Integer'
+      when Float
+        'Float'
+      when true, false
+        'Boolean'
+      when Array
+        'Array'
+      else
+        ''
+      end
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
+
+  def to_table(header, content)
+    table = [
+      '|===',
+      "| #{header.join(' | ')}\n\n"
+    ].join("\n")
+    marked_contents = content.map do |plain_content|
+      plain_content.map { |c| "| #{c}" }.join("\n")
+    end
+    table << marked_contents.join("\n\n")
+    table << "\n|===\n"
+  end
+
+  def format_table_value(val)
+    value =
+      case val
+      when Array
+        if val.empty?
+          '`[]`'
+        else
+          val.map { |config| format_table_value(config) }.join(', ')
+        end
+      else
+        wrap_backtick(val.nil? ? '<none>' : val)
+      end
+    value.gsub("#{Dir.pwd}/", '').rstrip
+  end
+
+  def wrap_backtick(value)
+    if value.is_a?(String)
+      # Use `+` to prevent text like `**/*.gemspec` from being bold.
+      value.start_with?('*') ? "`+#{value}+`" : "`#{value}`"
+    else
+      "`#{value}`"
+    end
+  end
+
+  def references(cop)
+    cop_config = config.for_cop(cop)
+    urls = RuboCop::Cop::MessageAnnotator.new(
+      config, cop.name, cop_config, {}
+    ).urls
+    return '' if urls.empty?
+
+    content = h3('References')
+    content << urls.map { |url| "* #{url}" }.join("\n")
+    content << "\n"
+    content
+  end
+
+  def print_cops_of_department(department)
+    selected_cops = cops_of_department(department)
+    content = +"= #{department}\n"
+    selected_cops.each do |cop|
+      content << print_cop_with_doc(cop)
+    end
+    file_name = "#{Dir.pwd}/docs/modules/ROOT/pages/#{department_to_basename(department)}.adoc"
+    File.open(file_name, 'w') do |file|
+      puts "* generated #{file_name}"
+      file.write("#{content.strip}\n")
+    end
+  end
+
+  def print_cop_with_doc(cop)
+    cop_config = config.for_cop(cop)
+    non_display_keys = %w[
+      Description Enabled StyleGuide Reference Safe SafeAutoCorrect VersionAdded
+      VersionChanged
+    ]
+    pars = cop_config.reject { |k| non_display_keys.include? k }
+    description = 'No documentation'
+    examples_object = []
+    cop_code(cop) do |code_object|
+      description = code_object.docstring unless code_object.docstring.blank?
+      examples_object = code_object.tags('example')
+    end
+    cops_body(cop, description, examples_object, pars)
+  end
+
+  def cop_code(cop)
+    YARD::Registry.all(:class).detect do |code_object|
+      next unless RuboCop::Cop::Badge.for(code_object.to_s) == cop.badge
+
+      yield code_object
+    end
+  end
+
+  def table_of_content_for_department(department)
+    type_title = department[0].upcase + department[1..-1]
+    filename = "#{department_to_basename(department)}.adoc"
+    content = +"=== Department xref:#{filename}[#{type_title}]\n\n"
+    cops_of_department(department).each do |cop|
+      anchor = cop.cop_name.sub('/', '').downcase
+      content << "* xref:#{filename}##{anchor}[#{cop.cop_name}]\n"
+    end
+
+    content
+  end
+
+  def print_table_of_contents
+    path = "#{Dir.pwd}/docs/modules/ROOT/pages/cops.adoc"
+    original = File.read(path)
+    content = +"// START_COP_LIST\n\n"
+
+    content << table_contents
+
+    content << "\n// END_COP_LIST"
+
+    content = original.sub(
+      %r{// START_COP_LIST.+// END_COP_LIST}m, content
+    )
+    File.write(path, content)
+  end
+
+  def table_contents
+    departments
+      .map { |department| table_of_content_for_department(department) }
+      .join("\n")
+  end
+
+  def cop_status(status)
+    return 'Disabled' unless status
+
+    status == 'pending' ? 'Pending' : 'Enabled'
+  end
+end