gitlab-styles 0.1.0

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

@@ -0,0 +1,52 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if indexes are added in a concurrent manner.
+          class AddIndex < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = '`add_index` requires downtime, use `add_concurrent_index` instead'.freeze
+
+            def on_def(node)
+              return unless in_migration?(node)
+
+              new_tables = []
+
+              node.each_descendant(:send) do |send_node|
+                first_arg = first_argument(send_node)
+
+                # The first argument of "create_table" / "add_index" is the table
+                # name.
+                new_tables << first_arg if create_table?(send_node)
+
+                next if method_name(send_node) != :add_index
+
+                # Using "add_index" is fine for newly created tables as there's no
+                # data in these tables yet.
+                next if new_tables.include?(first_arg)
+
+                add_offense(send_node, :selector)
+              end
+            end
+
+            def create_table?(node)
+              method_name(node) == :create_table
+            end
+
+            def method_name(node)
+              node.children[1]
+            end
+
+            def first_argument(node)
+              node.children[2] ? node.children[0] : nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if 'add_timestamps' method is called with timezone information.
+          class AddTimestamps < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = 'Do not use `add_timestamps`, use `add_timestamps_with_timezone` instead'.freeze
+
+            # Check methods.
+            def on_send(node)
+              return unless in_migration?(node)
+
+              add_offense(node, :selector) if method_name(node) == :add_timestamps
+            end
+
+            def method_name(node)
+              node.children[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if datetime data type is added with timezone information.
+          class Datetime < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = 'Do not use the `datetime` data type, use `datetime_with_timezone` instead'.freeze
+
+            # Check methods in table creation.
+            def on_def(node)
+              return unless in_migration?(node)
+
+              node.each_descendant(:send) do |send_node|
+                add_offense(send_node, :selector) if method_name(send_node) == :datetime
+              end
+            end
+
+            # Check methods.
+            def on_send(node)
+              return unless in_migration?(node)
+
+              node.each_descendant do |descendant|
+                add_offense(node, :expression) if descendant.type == :sym && descendant.children.last == :datetime
+              end
+            end
+
+            def method_name(node)
+              node.children[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'set'
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that prevents the use of hash indexes in database migrations
+          class HashIndex < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = 'hash indexes should be avoided at all costs since they are not ' \
+              'recorded in the PostgreSQL WAL, you should use a btree index instead'.freeze
+
+            NAMES = Set.new([:add_index, :index, :add_concurrent_index]).freeze
+
+            def on_send(node)
+              return unless in_migration?(node)
+
+              name = node.children[1]
+
+              return unless NAMES.include?(name)
+
+              opts = node.children.last
+
+              return unless opts&.type == :hash
+
+              opts.each_node(:pair) do |pair|
+                next unless hash_key_type(pair) == :sym &&
+                    hash_key_name(pair) == :using
+
+                if hash_key_value(pair).to_s == 'hash'
+                  add_offense(pair, :expression)
+                end
+              end
+            end
+
+            def hash_key_type(pair)
+              pair.children[0].type
+            end
+
+            def hash_key_name(pair)
+              pair.children[0].children[0]
+            end
+
+            def hash_key_value(pair)
+              pair.children[1].children[0]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if `remove_concurrent_index` is used with `up`/`down` methods
+          # and not `change`.
+          class RemoveConcurrentIndex < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = '`remove_concurrent_index` is not reversible so you must manually define ' \
+              'the `up` and `down` methods in your migration class, using `add_concurrent_index` in `down`'.freeze
+
+            def on_send(node)
+              return unless in_migration?(node)
+              return unless node.children[1] == :remove_concurrent_index
+
+              node.each_ancestor(:def) do |def_node|
+                add_offense(def_node, :name) if method_name(def_node) == :change
+              end
+            end
+
+            def method_name(node)
+              node.children[0]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if indexes are removed in a concurrent manner.
+          class RemoveIndex < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = '`remove_index` requires downtime, use `remove_concurrent_index` instead'.freeze
+
+            def on_def(node)
+              return unless in_migration?(node)
+
+              node.each_descendant(:send) do |send_node|
+                add_offense(send_node, :selector) if method_name(send_node) == :remove_index
+              end
+            end
+
+            def method_name(node)
+              node.children[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if `add_column_with_default` is used with `up`/`down` methods
+          # and not `change`.
+          class ReversibleAddColumnWithDefault < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            def_node_matcher :add_column_with_default?, <<~PATTERN
+              (send nil :add_column_with_default $...)
+            PATTERN
+
+            def_node_matcher :defines_change?, <<~PATTERN
+              (def :change ...)
+            PATTERN
+
+            MSG = '`add_column_with_default` is not reversible so you must manually define ' \
+              'the `up` and `down` methods in your migration class, using `remove_column` in `down`'.freeze
+
+            def on_send(node)
+              return unless in_migration?(node)
+              return unless add_column_with_default?(node)
+
+              node.each_ancestor(:def) do |def_node|
+                next unless defines_change?(def_node)
+
+                add_offense(def_node, :name)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # This cop requires a default value and disallows nulls for boolean
+          # columns on small tables.
+          #
+          # In general, this prevents 3-state-booleans.
+          # https://robots.thoughtbot.com/avoid-the-threestate-boolean-problem
+          #
+          # In particular, for the `application_settings` table, this ensures that
+          # upgraded installations get a proper default for the new boolean setting.
+          # A developer might otherwise mistakenly assume that a value in
+          # `ApplicationSetting.defaults` is sufficient.
+          #
+          # See https://gitlab.com/gitlab-org/gitlab-ee/issues/2750 for more
+          # information.
+          class SaferBooleanColumn < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            DEFAULT_OFFENSE = 'Boolean columns on the `%s` table should have a default. You may wish to use `add_column_with_default`.'.freeze
+            NULL_OFFENSE = 'Boolean columns on the `%s` table should disallow nulls.'.freeze
+            DEFAULT_AND_NULL_OFFENSE = 'Boolean columns on the `%s` table should have a default and should disallow nulls. You may wish to use `add_column_with_default`.'.freeze
+
+            SMALL_TABLES = %i[
+              application_settings
+            ].freeze
+
+            def_node_matcher :add_column?, <<~PATTERN
+              (send nil :add_column $...)
+            PATTERN
+
+            def on_send(node)
+              return unless in_migration?(node)
+
+              matched = add_column?(node)
+
+              return unless matched
+
+              table, _, type = matched.to_a.take(3).map(&:children).map(&:first)
+              opts = matched[3]
+
+              return unless SMALL_TABLES.include?(table) && type == :boolean
+
+              no_default = no_default?(opts)
+              nulls_allowed = nulls_allowed?(opts)
+
+              offense = if no_default && nulls_allowed
+                          DEFAULT_AND_NULL_OFFENSE
+                        elsif no_default
+                          DEFAULT_OFFENSE
+                        elsif nulls_allowed
+                          NULL_OFFENSE
+                        end
+
+              add_offense(node, :expression, format(offense, table)) if offense
+            end
+
+            def no_default?(opts)
+              return true unless opts
+
+              each_hash_node_pair(opts) do |key, value|
+                return value == 'nil' if key == :default
+              end
+            end
+
+            def nulls_allowed?(opts)
+              return true unless opts
+
+              each_hash_node_pair(opts) do |key, value|
+                return value != 'false' if key == :null
+              end
+            end
+
+            def each_hash_node_pair(hash_node, &block)
+              hash_node.each_node(:pair) do |pair|
+                key = hash_pair_key(pair)
+                value = hash_pair_value(pair)
+                yield(key, value)
+              end
+            end
+
+            def hash_pair_key(pair)
+              pair.children[0].children[0]
+            end
+
+            def hash_pair_value(pair)
+              pair.children[1].source
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if 'timestamps' method is called with timezone information.
+          class Timestamps < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = 'Do not use `timestamps`, use `timestamps_with_timezone` instead'.freeze
+
+            # Check methods in table creation.
+            def on_def(node)
+              return unless in_migration?(node)
+
+              node.each_descendant(:send) do |send_node|
+                add_offense(send_node, :selector) if method_name(send_node) == :timestamps
+              end
+            end
+
+            def method_name(node)
+              node.children[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # Cop that checks if a spec file exists for any migration using
+          # `update_column_in_batches`.
+          class UpdateColumnInBatches < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = 'Migration running `update_column_in_batches` must have a spec file at' \
+              ' `%s`.'.freeze
+
+            def on_send(node)
+              return unless in_migration?(node)
+              return unless node.children[1] == :update_column_in_batches
+
+              spec_path = spec_filename(node)
+
+              add_offense(node, :expression, format(MSG, spec_path)) unless File.exist?(File.expand_path(spec_path, rails_root))
+            end
+
+            private
+
+            def spec_filename(node)
+              source_name = node.location.expression.source_buffer.name
+              path = Pathname.new(source_name).relative_path_from(rails_root)
+              dirname = File.dirname(path)
+                .sub(%r{\Adb/(migrate|post_migrate)}, 'spec/migrations')
+              filename = File.basename(source_name, '.rb').sub(/\A\d+_/, '')
+
+              File.join(dirname, "#{filename}_spec.rb")
+            end
+
+            def rails_root
+              Pathname.new(File.expand_path('../../..', __dir__))
+            end
+          end
+        end
+      end
+    end
+  end
+end