gitlab-styles 3.4.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5f56cd42de5afd61307ea92fd0114cb64e79b575697800b948e6d3e42e32d7c
-  data.tar.gz: 25c343aae93b4bb8d03d57b92152c5c51433cacec86c86b6449ba8a6af3cc6e2
+  metadata.gz: f34644596ecbfd782a8a8d5781251743cbe2f0ef079467416c4e15c784769693
+  data.tar.gz: 531fb802e1a50564fbbfad34e96f66b8a2227e6c182999750a39456f2ae17c98
 SHA512:
-  metadata.gz: a7e7dbc2a80150595404fb1639266f462687668411b4410378a1021d9d07915fec14d6b34265d2a6672d65e5005cb4e2d7a1e99acff2ddbe0bc827280dc1c011
-  data.tar.gz: c0b9073e17bf0c11f283ef485612746c3baa1a6de27392029ca930413f939cc192d797e0a3a3016da2db0bdc219444c93129199fbba9ab81e533f86182c65d10
+  metadata.gz: 9a4036572db91754b18045e0e9ec40d9747a633773c49fb3edcdc53d0ac8b6ae2743f94ffe5fc2ce6cc8a60a51216eb7b85c89dfb039f747370cca4831c9cc41
+  data.tar.gz: 78eb2aaec9c221dad33fb99c719c3ad838a39f4978381b2f99ef011f87c8c8ee67a24d9b6e26af2eea4d1b3a03e03e80aab5c2718afaa998764a3cf68d8153e4

data/.editorconfig

@@ -0,0 +1,18 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{rb,yml}]
+indent_size = 2
+
+[*.{rb,yml,md}]
+indent_style = space
+charset = utf-8
+
+[*.{md,markdown}]
+trim_trailing_whitespace = false

data/.gitignore

@@ -9,3 +9,6 @@
 
 # rspec failure tracking
 .rspec_status
+
+# Ignore IDE specific files
+.idea/

data/.gitlab/merge_request_templates/Release.md

@@ -32,4 +32,4 @@ with the latest commit from https://gitlab.com/gitlab-org/gitlab-styles/commits/
 - Checklist after merging:
   - [ ] [Create a tag for the new release version](docs/release_process.md#how-to).
 
-/label ~"Engineering Productivity" ~backstage
+/label ~"Engineering Productivity" ~"tooling::workflow"

data/Gemfile

@@ -7,6 +7,7 @@ gemspec
 
 group :test do
   # Pin these dependencies, otherwise a new rule could break the CI pipelines
-  gem 'rubocop', '0.74.0'
-  gem 'rubocop-rspec', '1.36.0'
+  gem 'rubocop', '0.89.1'
+  gem 'rubocop-rspec', '1.44.1'
+  gem 'rspec-parameterized', '0.4.2', require: false
 end

data/README.md

@@ -42,6 +42,7 @@ rules:
 - `rubocop-gemspec.yml`
 - `rubocop-layout.yml`
 - `rubocop-lint.yml`
+- `rubocop-migrations.yml`
 - `rubocop-metrics.yml`
 - `rubocop-naming.yml`
 - `rubocop-performance.yml`

data/gitlab-styles.gemspec

@@ -5,6 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'gitlab/styles/version'
 
 Gem::Specification.new do |spec|
+  spec.required_ruby_version = '>= 2.6'
   spec.name          = 'gitlab-styles'
   spec.version       = Gitlab::Styles::VERSION
   spec.authors       = ['GitLab']
@@ -21,11 +22,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'rubocop', '~> 0.74.0'
+  spec.add_dependency 'rubocop', '~> 0.89.1'
   spec.add_dependency 'rubocop-gitlab-security', '~> 0.1.0'
-  spec.add_dependency 'rubocop-performance', '~> 1.4.1'
-  spec.add_dependency 'rubocop-rails', '~> 2.0'
-  spec.add_dependency 'rubocop-rspec', '~> 1.36'
+  spec.add_dependency 'rubocop-performance', '~> 1.8.1'
+  spec.add_dependency 'rubocop-rails', '~> 2.8'
+  spec.add_dependency 'rubocop-rspec', '~> 1.44'
 
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/gitlab/styles/rubocop.rb

@@ -8,10 +8,14 @@ require 'gitlab/styles/rubocop/cop/polymorphic_associations'
 require 'gitlab/styles/rubocop/cop/active_record_dependent'
 require 'gitlab/styles/rubocop/cop/in_batches'
 require 'gitlab/styles/rubocop/cop/line_break_after_guard_clauses'
+require 'gitlab/styles/rubocop/cop/code_reuse/active_record'
+require 'gitlab/styles/rubocop/cop/migration/update_large_table'
 require 'gitlab/styles/rubocop/cop/without_reactive_cache'
 require 'gitlab/styles/rubocop/cop/rspec/single_line_hook'
 require 'gitlab/styles/rubocop/cop/rspec/have_link_parameters'
 require 'gitlab/styles/rubocop/cop/rspec/verbose_include_metadata'
+require 'gitlab/styles/rubocop/cop/rspec/empty_line_after_shared_example'
+require 'gitlab/styles/rubocop/cop/rspec/empty_line_after_let_block'
 
 module Gitlab
   module Styles

data/lib/gitlab/styles/rubocop/cop/code_reuse/active_record.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module CodeReuse
+          # Cop that denies the use of ActiveRecord methods outside of models.
+          class ActiveRecord < RuboCop::Cop::Cop
+            MSG = 'This method can only be used inside an ActiveRecord model: ' \
+        'https://gitlab.com/gitlab-org/gitlab-foss/issues/49653'
+
+            # Various methods from ActiveRecord::Querying that are denied. We
+            # exclude some generic ones such as `any?` and `first`, as these may
+            # lead to too many false positives, since `Array` also supports these
+            # methods.
+            #
+            # The keys of this Hash are the denied method names. The values are
+            # booleans that indicate if the method should only be denied if any
+            # arguments are provided.
+            NOT_ALLOWED = {
+              average: true,
+              calculate: true,
+              count_by_sql: true,
+              create_with: true,
+              distinct: false,
+              eager_load: true,
+              exists?: true,
+              find_by: true,
+              find_by!: true,
+              find_by_sql: true,
+              find_each: true,
+              find_in_batches: true,
+              find_or_create_by: true,
+              find_or_create_by!: true,
+              find_or_initialize_by: true,
+              first!: false,
+              first_or_create: true,
+              first_or_create!: true,
+              first_or_initialize: true,
+              from: true,
+              group: true,
+              having: true,
+              ids: false,
+              includes: true,
+              joins: true,
+              limit: true,
+              lock: false,
+              many?: false,
+              offset: true,
+              order: true,
+              pluck: true,
+              preload: true,
+              readonly: false,
+              references: true,
+              reorder: true,
+              rewhere: true,
+              take: false,
+              take!: false,
+              unscope: false,
+              where: false,
+              with: true
+            }.freeze
+
+            def on_send(node)
+              receiver = node.children[0]
+              send_name = node.children[1]
+              first_arg = node.children[2]
+
+              return unless receiver && NOT_ALLOWED.key?(send_name)
+
+              # If the rule requires an argument to be given, but none are
+              # provided, we won't register an offense. This prevents us from
+              # adding offenses for `project.group`, while still covering
+              # `Project.group(:name)`.
+              return if NOT_ALLOWED[send_name] && !first_arg
+
+              add_offense(node, location: :selector)
+            end
+
+            # We can not auto correct code like this, as it requires manual
+            # refactoring. Instead, we'll just allow the surrounding scope.
+            #
+            # Despite this method's presence, you should not use it. This method
+            # exists to make it possible to allow large chunks of offenses we
+            # can't fix in the short term. If you are writing new code, follow the
+            # code reuse guidelines, instead of allowing any new offenses.
+            def autocorrect(node)
+              scope = surrounding_scope_of(node)
+              indent = indentation_of(scope)
+
+              lambda do |corrector|
+                # This prevents us from inserting the same enable/disable comment
+                # for a method or block that has multiple offenses.
+                next if allowed_scopes.include?(scope)
+
+                corrector.insert_before(
+                  scope.source_range,
+                  "# rubocop: disable #{cop_name}\n#{indent}"
+                )
+
+                corrector.insert_after(
+                  scope.source_range,
+                  "\n#{indent}# rubocop: enable #{cop_name}"
+                )
+
+                allowed_scopes << scope
+              end
+            end
+
+            def indentation_of(node)
+              ' ' * node.loc.expression.source_line[/\A */].length
+            end
+
+            def surrounding_scope_of(node)
+              %i[def defs block begin].each do |type|
+                if (found = node.each_ancestor(type).first)
+                  return found
+                end
+              end
+            end
+
+            def allowed_scopes
+              @allowed_scopes ||= Set.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    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 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, location: :expression, 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
+  end
+end

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

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

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Gitlab
+  module Styles
+    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
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Gitlab
+  module Styles
+    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
+  end
+end