gitlab-styles 7.0.0 → 9.0.0

data/lib/rubocop/cop/line_break_after_guard_clauses.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Rubocop
+  module Cop
+    # Ensures a line break after guard clauses.
+    #
+    # @example
+    #   # bad
+    #   return unless condition
+    #   do_stuff
+    #
+    #   # good
+    #   return unless condition
+    #
+    #   do_stuff
+    #
+    #   # bad
+    #   raise if condition
+    #   do_stuff
+    #
+    #   # good
+    #   raise if condition
+    #
+    #   do_stuff
+    #
+    #   Multiple guard clauses are allowed without
+    #   line break.
+    #
+    #   # good
+    #   return unless condition_a
+    #   return unless condition_b
+    #
+    #   do_stuff
+    #
+    #   Guard clauses in case statement are allowed without
+    #   line break.
+    #
+    #   # good
+    #   case model
+    #     when condition_a
+    #       return true unless condition_b
+    #     when
+    #       ...
+    #   end
+    #
+    #   Guard clauses before end are allowed without
+    #   line break.
+    #
+    #   # good
+    #   if condition_a
+    #     do_something
+    #   else
+    #     do_something_else
+    #     return unless condition
+    #   end
+    #
+    #   do_something_more
+    class LineBreakAfterGuardClauses < RuboCop::Cop::Base
+      MSG = 'Add a line break after guard clauses'
+
+      # @!method guard_clause_node?(node)
+      def_node_matcher :guard_clause_node?, <<-PATTERN
+        [{(send nil? {:raise :fail :throw} ...) return break next} single_line?]
+      PATTERN
+
+      def on_if(node)
+        return unless node.single_line?
+        return unless guard_clause?(node)
+        return if next_line(node).blank? || clause_last_line?(next_line(node)) || guard_clause?(next_sibling(node))
+
+        add_offense(node)
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          corrector.insert_after(node.loc.expression, "\n")
+        end
+      end
+
+      private
+
+      def guard_clause?(node)
+        return false unless node.if_type?
+
+        guard_clause_node?(node.if_branch)
+      end
+
+      def next_sibling(node)
+        node.parent.children[node.sibling_index + 1]
+      end
+
+      def next_line(node)
+        processed_source[node.loc.line]
+      end
+
+      def clause_last_line?(line)
+        line =~ /^\s*(?:end|elsif|else|when|rescue|ensure)/
+      end
+    end
+  end
+end

data/lib/rubocop/cop/line_break_around_conditional_block.rb

@@ -0,0 +1,127 @@
+# 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::Base
+      extend RuboCop::Cop::AutoCorrector
+      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?
+
+        corrector_block = 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
+
+        add_offense(node, &corrector_block) unless previous_line_valid?(node)
+        add_offense(node, &corrector_block) unless last_line_valid?(node)
+      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,61 @@
+# frozen_string_literal: true
+require_relative '../../../gitlab/styles/rubocop/migration_helpers'
+
+module Rubocop
+  module Cop
+    module Migration
+      # 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::Base
+        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'
+
+        # @!method batch_update?(node)
+        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,36 @@
+# frozen_string_literal: true
+
+module Rubocop
+  module Cop
+    module Performance
+      # 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::Base
+        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.'
+
+        # @!method reads_central_directory?(node)
+        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::Base
+      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,28 @@
+# frozen_string_literal: true
+
+require_relative '../../../gitlab/styles/rubocop/model_helpers'
+
+module Rubocop
+  module Cop
+    module Rails
+      class IncludeUrlHelper < RuboCop::Cop::Base
+        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
+
+        # @!method include_url_helpers_node?(node)
+        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
+    # 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::Base
+      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.loc.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,12 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+
+module Rubocop
+  module Cop
+    module RSpec
+      class Base < RuboCop::Cop::RSpec::Base
+      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::Cop::RSpec::EmptyLineSeparation
+
+        MSG = 'Add an empty line after `%<let>s` block.'
+
+        def on_block(node)
+          RuboCop::RSpec::ExampleGroup.new(node).lets.each do |let|
+            break if last_child?(let)
+            next if let.single_line?
+
+            missing_separating_line_offense(let) do |method|
+              format(MSG, let: method)
+              format(MSG, let: method)
+            end
+          end
+        end
+        alias_method :on_numblock, :on_block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# 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::Cop::RSpec::EmptyLineSeparation
+
+        MSG = 'Add an empty line after `%<example>s` block.'
+
+        # @!method shared_examples(node)
+        def_node_matcher :shared_examples,
+                         block_pattern('{#SharedGroups.all #Includes.all}')
+
+        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
+        alias_method :on_numblock, :on_block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# 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.'
+
+        # @!method it_description(node)
+        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
+        alias_method :on_numblock, :on_block
+
+        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