rubocop-mismatched-foreign-key-type 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7806c9473411325f857346dec50a0bfbd26446c245a01cca4afe9e0f365232f
+  data.tar.gz: 01cd58f6564b755edfac4b256dfe5efd8e1535345f660e9a2dba98a4cfb56990
+SHA512:
+  metadata.gz: d29bf6f4ccec1216fec2f3d7525b689746ee18ce040c761d9a2e3157dc1de65b037e4deee698c86f87cdb5f38584b07a38ac4deedd8bd2f54ccb8e0dcaadd8a6
+  data.tar.gz: 3a601d99511f6071975f6548ceafc48f002af2403f139d1816fb4a09781212b962a91b405e512ba29d81ff934d3443cd0f5c58419f2363223d196136f9fb5b93

data/config/default.yml

@@ -0,0 +1,7 @@
+require:
+  - rubocop-mismatched-foreign-key-type
+
+Rails/MismatchedForeignKeyType:
+  Enabled: true
+  Include:
+    - 'db/schema.rb'

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for foreign key type mismatches in db/schema.rb.
+      # It detects when a table uses `t.integer :xxx_id` but the referenced
+      # table's primary key is `bigint` (Rails 5.1+ default).
+      #
+      # @example
+      #   # bad
+      #   create_table "users", force: :cascade do |t|
+      #     ...
+      #   end
+      #
+      #   create_table "posts", force: :cascade do |t|
+      #     t.integer "user_id"
+      #   end
+      #
+      #   # good
+      #   create_table "users", force: :cascade do |t|
+      #     ...
+      #   end
+      #
+      #   create_table "posts", force: :cascade do |t|
+      #     t.bigint "user_id"
+      #   end
+      class MismatchedForeignKeyType < RuboCop::Cop::Base
+        MSG = 'Use bigint for foreign keys that reference bigint primary keys.'
+
+        def initialize(*args)
+          super
+          @table_pk_types = {}
+        end
+
+        # Called before all on_xxx callbacks are executed.
+        def on_new_investigation
+          super
+
+          processed_source.ast.each_node(:send) do |node|
+            next unless node.method?(:create_table)
+
+            table_name = extract_table_name(node)
+            next unless table_name
+
+            @table_pk_types[table_name] = extract_pk_type(node)
+          end
+        end
+
+        def on_send(node)
+          return unless node.method?(:create_table)
+
+          block = node.block_node
+          check_integer_foreign_keys(block) if block
+        end
+
+        private
+
+        def extract_table_name(node)
+          table_name_node = node.arguments.first
+          return unless table_name_node&.str_type?
+
+          table_name_node.value
+        end
+
+        def extract_pk_type(node)
+          node.arguments.each do |arg|
+            next unless arg.hash_type?
+
+            pk_type = extract_pk_type_from_hash(arg)
+            return pk_type if pk_type
+          end
+
+          # Default to bigint (Rails 5.1+)
+          :bigint
+        end
+
+        def extract_pk_type_from_hash(hash_node)
+          hash_node.each_pair do |key, value|
+            next unless key.sym_type? && key.value == :id
+            next unless value.sym_type?
+
+            case value.value
+            when :integer then return :integer
+            when :bigint then return :bigint
+            end
+          end
+          nil
+        end
+
+        def check_integer_foreign_keys(block_node)
+          return unless block_node.body
+
+          block_node.body.each_node(:send) do |send_node|
+            next unless send_node.method_name == :integer
+
+            check_integer_foreign_key(send_node)
+          end
+        end
+
+        def check_integer_foreign_key(send_node)
+          fk_name = send_node.arguments.first&.value
+          return unless fk_name&.end_with?('_id')
+
+          referenced_table = extract_referenced_table(fk_name)
+          referenced_pk_type = @table_pk_types[referenced_table]
+          return unless referenced_pk_type == :bigint
+
+          add_offense(send_node, message: MSG)
+        end
+
+        def extract_referenced_table(fk_name)
+          base = fk_name.delete_suffix('_id')
+          base.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/mismatched_foreign_key_type/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module MismatchedForeignKeyType
+    VERSION = '0.1.0'
+  end
+end

data/lib/rubocop-mismatched-foreign-key-type.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'rubocop/cop/rails/mismatched_foreign_key_type'

data/spec/rubocop/cop/rails/mismatched_foreign_key_type_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RuboCop::Cop::Rails::MismatchedForeignKeyType, :config do
+  let(:config) do
+    RuboCop::Config.new(
+      'Rails/MismatchedForeignKeyType' => {
+        'Enabled' => true
+      }
+    )
+  end
+
+  describe 'MismatchedForeignKeyType' do
+    context 'when an incorrect foreign key type is used' do
+      it 'registers an offense for implicit bigint primary key' do
+        expect_offense(<<~RUBY)
+          create_table "users", force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_id"
+            ^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+        RUBY
+      end
+
+      it 'registers an offense for explicit bigint primary key' do
+        expect_offense(<<~RUBY)
+          create_table "users", id: :bigint, force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_id"
+            ^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+        RUBY
+      end
+
+      it 'registers offenses for multiple bigint primary keys' do
+        expect_offense(<<~RUBY)
+          create_table "users", force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "categories", force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_id"
+            ^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+            t.integer "category_id"
+            ^^^^^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+        RUBY
+      end
+
+      it 'registers an offense for foreign keys referencing tables with underscores' do
+        expect_offense(<<~RUBY)
+          create_table "user_profiles", force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_profile_id"
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+        RUBY
+      end
+
+      it 'registers offenses for various pluralization patterns' , :aggregate_failures do
+        expect_offense(<<~RUBY)
+          create_table "categories", force: :cascade do |t|
+              t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+              t.integer "category_id"
+              ^^^^^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+        RUBY
+
+        expect_offense(<<~RUBY)
+          create_table "addresses", force: :cascade do |t|
+              t.string "street"
+          end
+
+          create_table "users", force: :cascade do |t|
+              t.integer "address_id"
+              ^^^^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+        RUBY
+
+        expect_offense(<<~RUBY)
+          create_table "people", force: :cascade do |t|
+              t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+              t.integer "person_id"
+              ^^^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+        RUBY
+      end
+
+      it 'registers offense even if referenced table is defined laster' do
+        expect_offense(<<~RUBY)
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_id"
+            ^^^^^^^^^^^^^^^^^^^ Use bigint for foreign keys that reference bigint primary keys.
+          end
+
+          create_table "users", force: :cascade do |t|
+            t.string "name"
+          end
+        RUBY
+      end
+    end
+
+    context 'when the correct foreign key type is used' do
+      it 'does not register an offense for bigint foreign key referencing bigint primary key' do
+        expect_no_offenses(<<~RUBY)
+          create_table "users", force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.bigint "user_id"
+          end
+        RUBY
+      end
+
+      it 'does not register an offense for integer foreign key referencing integer primary key' do
+        expect_no_offenses(<<~RUBY)
+          create_table "users", id: :integer, force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_id"
+          end
+        RUBY
+      end
+    end
+
+    context 'when not recognized as a foreign key' do
+      it 'does not register an offense if there is no foreign key column' do
+        expect_no_offenses(<<~RUBY)
+          create_table "users", force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.string "title"
+            t.text "content"
+          end
+        RUBY
+      end
+
+      it 'does not register an offense if the referenced table does not exist' do
+        expect_no_offenses(<<~RUBY)
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_id"
+          end
+        RUBY
+      end
+
+      it 'does not register an offense for columns not ending with _id' do
+        expect_no_offenses(<<~RUBY)
+          create_table "users", force: :cascade do |t|
+            t.string "name"
+          end
+
+          create_table "posts", force: :cascade do |t|
+            t.integer "user_reference"
+          end
+        RUBY
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'rubocop/rspec/support'
+require "rubocop-mismatched-foreign-key-type"
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-mismatched-foreign-key-type
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yohei.hokari
+bindir: bin
+cert_chain: []
+date: 2025-12-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: This cop identifies integer foreign keys that should be biginteger, based
+  on the primary key of the referenced table.
+email:
+- yohei.hokari@optim.co.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- config/default.yml
+- lib/rubocop-mismatched-foreign-key-type.rb
+- lib/rubocop/cop/rails/mismatched_foreign_key_type.rb
+- lib/rubocop/mismatched_foreign_key_type/version.rb
+- spec/rubocop/cop/rails/mismatched_foreign_key_type_spec.rb
+- spec/spec_helper.rb
+homepage: https://gitlab.tokyo.optim.co.jp/yohei.hokari/rubocop-mismatched-foreign-key-type
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://gitlab.tokyo.optim.co.jp/yohei.hokari/rubocop-mismatched-foreign-key-type
+  source_code_uri: https://gitlab.tokyo.optim.co.jp/yohei.hokari/rubocop-mismatched-foreign-key-type
+  changelog_uri: https://gitlab.tokyo.optim.co.jp/yohei.hokari/rubocop-mismatched-foreign-key-type/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A RuboCop extension to check for mismatched foreign key types in schema.rb.
+test_files: []