gitlab-styles 7.1.0 → 8.0.0

data/lib/rubocop/cop/line_break_around_conditional_block.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Rubocop
+  module Cop
+    # Ensures a line break around conditional blocks.
+    #
+    # @example
+    #    # bad
+    #    do_something
+    #    if condition
+    #      do_extra_stuff
+    #    end
+    #    do_something_more
+    #
+    #    # good
+    #    do_something
+    #
+    #    if condition
+    #      do_extra_stuff
+    #    end
+    #
+    #    do_something_more
+    #
+    #    # bad
+    #    do_something
+    #    unless condition
+    #      do_extra_stuff
+    #    end
+    #
+    #    do_something_more
+    #
+    #    # good
+    #    def a_method
+    #      if condition
+    #        do_something
+    #      end
+    #    end
+    #
+    #    # good
+    #    on_block do
+    #      if condition
+    #        do_something
+    #      end
+    #    end
+    class LineBreakAroundConditionalBlock < RuboCop::Cop::Cop
+      include RuboCop::Cop::RangeHelp
+
+      MSG = 'Add a line break around conditional blocks'
+
+      def on_if(node)
+        # This cop causes errors in haml files, so let's skip those
+        return if in_haml?(node)
+        return if node.single_line?
+        return unless node.if? || node.unless?
+
+        add_offense(node) unless previous_line_valid?(node)
+        add_offense(node) unless last_line_valid?(node)
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          line = range_by_whole_lines(node.source_range)
+
+          corrector.insert_before(line, "\n") unless previous_line_valid?(node)
+          corrector.insert_after(line, "\n") unless last_line_valid?(node)
+        end
+      end
+
+      private
+
+      def previous_line_valid?(node)
+        previous_line(node).empty? ||
+          start_clause_line?(previous_line(node)) ||
+          block_start?(previous_line(node)) ||
+          begin_line?(previous_line(node)) ||
+          assignment_line?(previous_line(node)) ||
+          rescue_line?(previous_line(node))
+      end
+
+      def last_line_valid?(node)
+        last_line(node).empty? ||
+          end_line?(last_line(node)) ||
+          end_clause_line?(last_line(node))
+      end
+
+      def previous_line(node)
+        processed_source[node.loc.line - 2]
+      end
+
+      def last_line(node)
+        processed_source[node.loc.last_line]
+      end
+
+      def start_clause_line?(line)
+        line =~ /^\s*(def|=end|#|module|class|if|unless|else|elsif|ensure|when)/
+      end
+
+      def end_clause_line?(line)
+        line =~ /^\s*(#|rescue|else|elsif|when)/
+      end
+
+      def begin_line?(line)
+        # an assignment followed by a begin or ust a begin
+        line =~ /^\s*(@?(\w|\|+|=|\[|\]|\s)+begin|begin)/
+      end
+
+      def assignment_line?(line)
+        line =~ /^\s*.*=/
+      end
+
+      def rescue_line?(line)
+        line =~ /^\s*rescue/
+      end
+
+      def block_start?(line)
+        line.match(/ (do|{)( \|.*?\|)?\s?(#.+)?\z/)
+      end
+
+      def end_line?(line)
+        line =~ /^\s*(end|})/
+      end
+
+      def in_haml?(node)
+        node.location.expression.source_buffer.name.end_with?('.haml.rb')
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/update_large_table.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require_relative '../../../gitlab/styles/rubocop/migration_helpers'
+
+module Rubocop
+  module Cop
+    module Migration
+      # This cop checks for methods that may lead to batch type issues on a table that's been
+      # explicitly denied because of its size.
+      #
+      # Even though though these methods perform functions to avoid
+      # downtime, using it with tables with millions of rows still causes a
+      # significant delay in the deploy process and is best avoided.
+      #
+      # See https://gitlab.com/gitlab-com/infrastructure/issues/1602 for more
+      # information.
+      class UpdateLargeTable < RuboCop::Cop::Cop
+        include Gitlab::Styles::Rubocop::MigrationHelpers
+
+        MSG = 'Using `%s` on the `%s` table will take a long time to ' \
+          'complete, and should be avoided unless absolutely ' \
+          'necessary'
+
+        def_node_matcher :batch_update?, <<~PATTERN
+          (send nil? ${#denied_method?}
+            (sym $...)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return if denied_tables.empty? || denied_methods.empty?
+          return unless in_migration?(node)
+
+          matches = batch_update?(node)
+          return unless matches
+
+          update_method = matches.first
+          table = matches.last.to_a.first
+
+          return unless denied_tables.include?(table)
+
+          add_offense(node, message: format(MSG, update_method, table))
+        end
+
+        private
+
+        def denied_tables
+          cop_config['DeniedTables'] || []
+        end
+
+        def denied_method?(method_name)
+          denied_methods.include?(method_name)
+        end
+
+        def denied_methods
+          cop_config['DeniedMethods'] || []
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/rubyzip.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rubocop
+  module Cop
+    module Performance
+      # This cop flags inefficient uses of rubyzip's Zip::File, since when instantiated
+      # it reads the file's Central Directory into memory entirely. For zips with many
+      # files and directories, this can be very expensive even when the archive's size
+      # in bytes is small.
+      #
+      # See also:
+      # - https://github.com/rubyzip/rubyzip/issues/506
+      # - https://github.com/rubyzip/rubyzip#notes-on-zipinputstream
+      class Rubyzip < RuboCop::Cop::Cop
+        MSG = 'Be careful when opening or iterating zip files via Zip::File. ' \
+              'Zip archives may contain many entries, and their file index is ' \
+              'read into memory upon construction, which can lead to ' \
+              'high memory use and poor performance. ' \
+              'Consider iterating archive entries via Zip::InputStream instead.'
+
+        def_node_matcher :reads_central_directory?, <<-PATTERN
+          (send
+            (const
+              (const {nil? (cbase)} :Zip) :File) {:new :open :foreach} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless reads_central_directory?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/polymorphic_associations.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../../gitlab/styles/rubocop/model_helpers'
+
+module Rubocop
+  module Cop
+    # Cop that prevents the use of polymorphic associations
+    class PolymorphicAssociations < RuboCop::Cop::Cop
+      include Gitlab::Styles::Rubocop::ModelHelpers
+
+      MSG = 'Do not use polymorphic associations, use separate tables instead'
+
+      def on_send(node)
+        return unless in_model?(node)
+        return unless node.children[1] == :belongs_to
+
+        node.children.last.each_node(:pair) do |pair|
+          key_name = pair.children[0].children[0]
+
+          add_offense(pair) if key_name == :polymorphic
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/include_url_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../../gitlab/styles/rubocop/model_helpers'
+
+module Rubocop
+  module Cop
+    module Rails
+      class IncludeUrlHelper < RuboCop::Cop::Cop
+        MSG = <<~MSG
+          Avoid including `ActionView::Helpers::UrlHelper`.
+          It adds/overrides ~40 methods while usually only one is needed.
+          Instead, use the `Gitlab::Routing.url_helpers`/`Application.routes.url_helpers`(outside of gitlab)
+          and `ActionController::Base.helpers.link_to`.
+          See https://gitlab.com/gitlab-org/gitlab/-/issues/340567.
+        MSG
+
+        def_node_matcher :include_url_helpers_node?, <<~PATTERN
+          (send nil? :include (const (const (const {nil? cbase} :ActionView) :Helpers) :UrlHelper))
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if include_url_helpers_node?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/redirect_with_status.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rubocop
+  module Cop
+    # This cop prevents usage of 'redirect_to' in actions 'destroy' without specifying 'status'.
+    # See https://gitlab.com/gitlab-org/gitlab-ce/issues/31840
+    class RedirectWithStatus < RuboCop::Cop::Cop
+      MSG = 'Do not use "redirect_to" without "status" in "destroy" action'
+
+      def on_def(node)
+        return unless in_controller?(node)
+        return unless destroy?(node) || destroy_all?(node)
+
+        node.each_descendant(:send) do |def_node|
+          next unless redirect_to?(def_node)
+
+          methods = []
+
+          def_node.children.last.each_node(:pair) do |pair|
+            methods << pair.children.first.children.first
+          end
+
+          add_offense(def_node, location: :selector) unless methods.include?(:status)
+        end
+      end
+
+      private
+
+      def in_controller?(node)
+        node.location.expression.source_buffer.name.end_with?('_controller.rb')
+      end
+
+      def destroy?(node)
+        node.children.first == :destroy
+      end
+
+      def destroy_all?(node)
+        node.children.first == :destroy_all
+      end
+
+      def redirect_to?(node)
+        node.children[1] == :redirect_to
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative '../../../gitlab/styles/rubocop/rspec/helpers'
+
+module Rubocop
+  module Cop
+    module RSpec
+      class Base < RuboCop::Cop::RSpec::Base
+        include Gitlab::Styles::Rubocop::Rspec::Helpers
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_final_let_it_be.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Rubocop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after the last `let_it_be` block.
+      #
+      # @example
+      #   # bad
+      #   let_it_be(:foo) { bar }
+      #   let_it_be(:something) { other }
+      #   it { does_something }
+      #
+      #   # good
+      #   let_it_be(:foo) { bar }
+      #   let_it_be(:something) { other }
+      #
+      #   it { does_something }
+      class EmptyLineAfterFinalLetItBe < Base
+        extend RuboCop::Cop::AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
+
+        MSG = 'Add an empty line after the last `let_it_be`.'
+
+        def_node_matcher :let_it_be?, <<-PATTERN
+          {
+            (block (send #rspec? {:let_it_be :let_it_be_with_refind :let_it_be_with_reload} ...) ...)
+            (send #rspec? {:let_it_be :let_it_be_with_refind :let_it_be_with_reload} _ block_pass)
+          }
+        PATTERN
+
+        def on_block(node)
+          return unless example_group_with_body?(node)
+
+          final_let_it_be = node.body.child_nodes.reverse.find { |child| let_it_be?(child) }
+
+          return if final_let_it_be.nil?
+
+          missing_separating_line_offense(final_let_it_be) { MSG }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_let_block.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Rubocop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after let blocks.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe Foo do
+      #     let(:something) { 'something' }
+      #     let(:another_thing) do
+      #     end
+      #     let(:something_else) do
+      #     end
+      #     let(:last_thing) { 'last thing' }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe Foo do
+      #     let(:something) { 'something' }
+      #     let(:another_thing) do
+      #     end
+      #
+      #     let(:something_else) do
+      #     end
+      #
+      #     let(:last_thing) { 'last thing' }
+      #   end
+      #
+      #   # good - it's ok to have non-separated without do/end blocks
+      #   RSpec.describe Foo do
+      #     let(:something) { 'something' }
+      #     let(:last_thing) { 'last thing' }
+      #   end
+      #
+      class EmptyLineAfterLetBlock < Base
+        extend RuboCop::Cop::AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
+
+        MSG = 'Add an empty line after `%<let>s` block.'
+
+        def_node_matcher :lets, LET.block_pattern
+
+        def on_block(node)
+          lets(node) do
+            break if last_child?(node)
+            next if node.single_line?
+
+            missing_separating_line_offense(node) do |method|
+              format(MSG, let: method)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_line_after_shared_example.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Rubocop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after shared example blocks.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe Foo do
+      #     it_behaves_like 'do this first'
+      #     it_behaves_like 'does this' do
+      #     end
+      #     it_behaves_like 'does that' do
+      #     end
+      #     it_behaves_like 'do some more'
+      #   end
+      #
+      #   # good
+      #   RSpec.describe Foo do
+      #     it_behaves_like 'do this first'
+      #     it_behaves_like 'does this' do
+      #     end
+      #
+      #     it_behaves_like 'does that' do
+      #     end
+      #
+      #     it_behaves_like 'do some more'
+      #   end
+      #
+      #   # fair - it's ok to have non-separated without blocks
+      #   RSpec.describe Foo do
+      #     it_behaves_like 'do this first'
+      #     it_behaves_like 'does this'
+      #   end
+      #
+      class EmptyLineAfterSharedExample < Base
+        extend RuboCop::Cop::AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
+
+        MSG = 'Add an empty line after `%<example>s` block.'
+
+        def_node_matcher :shared_examples,
+                         (SharedGroups::ALL + Includes::ALL).block_pattern
+
+        def on_block(node)
+          shared_examples(node) do
+            break if last_child?(node)
+
+            missing_separating_line_offense(node) do |method|
+              format(MSG, example: method)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/example_starting_character.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Rubocop
+  module Cop
+    module RSpec
+      # Checks for common mistakes in example descriptions.
+      #
+      # This cop will correct docstrings that begin/end with space or words that start with a capital letter.
+      #
+      # @see https://gitlab.com/gitlab-org/gitlab/-/merge_requests/46336#note_442669518
+      #
+      # @example
+      #   # bad
+      #   it 'Does something' do
+      #   end
+      #
+      #   # good
+      #   it 'does nothing' do
+      #   end
+      #
+      # @example
+      #   # bad
+      #   it ' does something' do
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #   end
+      #
+      # @example
+      #   # bad
+      #   it 'does something ' do
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #   end
+      #
+      # @example
+      #   # bad
+      #   it ' does something ' do
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #   end
+      class ExampleStartingCharacter < Base
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = 'Only start words with lowercase alpha with no leading/trailing spaces when describing your tests.'
+
+        def_node_matcher :it_description, <<-PATTERN
+      (block (send _ :it ${
+        (str $_)
+        (dstr (str $_ ) ...)
+      } ...) ...)
+        PATTERN
+
+        def on_block(node)
+          it_description(node) do |description_node, _message|
+            add_wording_offense(description_node, MSG) if invalid_description?(text(description_node))
+          end
+        end
+
+        private
+
+        def add_wording_offense(node, message)
+          docstring = docstring(node)
+          add_offense(docstring, message: message) do |corrector|
+            corrector.replace(docstring, replacement_text(node))
+          end
+        end
+
+        def docstring(node)
+          expr = node.loc.expression
+
+          Parser::Source::Range.new(
+            expr.source_buffer,
+            expr.begin_pos + 1,
+            expr.end_pos - 1
+          )
+        end
+
+        def invalid_description?(message)
+          message.match?(/(^([A-Z]{1}[a-z]+\s|\s)|\s$)/)
+        end
+
+        def replacement_text(node)
+          text = text(node)
+
+          text.strip!
+
+          text = downcase_first_letter(text) if invalid_description?(text)
+
+          text
+        end
+
+        # Recursive processing is required to process nested dstr nodes
+        # that is the case for \-separated multiline strings with interpolation.
+        def text(node)
+          case node.type
+          when :dstr
+            node.node_parts.map { |child_node| text(child_node) }.join
+          when :str
+            node.value
+          when :begin
+            node.source
+          end
+        end
+
+        def downcase_first_letter(str)
+          str[0].downcase + str[1..]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/have_link_parameters.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Rubocop
+  module Cop
+    module RSpec
+      # This cop checks for unused parameters to the `have_link` matcher.
+      #
+      # @example
+      #
+      #   # bad
+      #   expect(page).to have_link('Link', 'https://example.com')
+      #
+      #   # good
+      #   expect(page).to have_link('Link', href: 'https://example.com')
+      #   expect(page).to have_link('Example')
+      class HaveLinkParameters < Base
+        extend RuboCop::Cop::AutoCorrector
+
+        MESSAGE = "The second argument to `have_link` should be a Hash."
+
+        def_node_matcher :unused_parameters?, <<~PATTERN
+          (send nil? :have_link
+            _ !{hash nil}
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless unused_parameters?(node)
+
+          location = node.arguments[1..]
+                       .map(&:source_range)
+                       .reduce(:join)
+
+          add_offense(location, message: MESSAGE) do |corrector|
+            corrector.insert_after(location.end, "\n")
+          end
+        end
+      end
+    end
+  end
+end