gitlab-styles 6.6.0 → 8.0.0

data/lib/rubocop/cop/line_break_after_guard_clauses.rb

@@ -0,0 +1,100 @@
+# 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::Cop
+      MSG = 'Add a line break after guard clauses'
+
+      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,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