pg_trunk 0.1.0

data/lib/pg_trunk/core/railtie.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk
+  # @private
+  # Turn in PGTrunk-relates stuff in the Rails app
+  class Railtie < Rails::Railtie
+    require_relative "railtie/command_recorder"
+    require_relative "railtie/custom_types"
+    require_relative "railtie/migration"
+    require_relative "railtie/migrator"
+    require_relative "railtie/schema_dumper"
+    require_relative "railtie/schema_migration"
+    require_relative "railtie/statements"
+
+    initializer("pg_trunk.load") do
+      ActiveSupport.on_load(:active_record) do
+        # overload schema dumper to use gem-specific object fetchers
+        ActiveRecord::SchemaDumper.prepend PGTrunk::SchemaDumper
+        # add custom type casting
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend PGTrunk::CustomTypes
+        # add migration methods
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend PGTrunk::Statements
+        # register those methods for migration directions
+        ActiveRecord::Migration::CommandRecorder.include PGTrunk::CommandRecorder
+        # support the registry table `pg_trunk` in addition to `schema_migrations`
+        ActiveRecord::SchemaMigration.prepend PGTrunk::SchemaMigration
+        # fix migration to enable different syntax without the name of the table
+        ActiveRecord::Migration.prepend PGTrunk::Migration
+        # make the migrator to remove stale records from `pg_trunk`
+        ActiveRecord::Migrator.prepend PGTrunk::Migrator
+      end
+    end
+  end
+end

data/lib/pg_trunk/core/registry.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module PGTrunk
+  # @private
+  # The internal model to represent the gem-specific registry
+  # where we store information about objects added by migrations.
+  #
+  # Every time when an object is created, we should record it
+  # in the table, setting its `oid` along with the reference
+  # to the system table (`classid::oid`).
+  #
+  # The third column `version::text` keeps the current version
+  # where the object has been added.
+  #
+  # rubocop: disable Metrics/ClassLength
+  class Registry < ActiveRecord::Base
+    class << self
+      def _internal?
+        true
+      end
+
+      def primary_key
+        "oid"
+      end
+
+      def table_name
+        "pg_trunk"
+      end
+
+      # rubocop: disable Metrics/MethodLength
+      def create_table
+        return if connection.table_exists?(table_name)
+
+        connection.create_table(
+          table_name,
+          id: false,
+          if_not_exists: true,
+          comment: "Objects added by migrations",
+        ) do |t|
+          t.column :oid, :oid, primary_key: true, comment: "Object identifier"
+          t.column :classid, :oid, null: false, comment: \
+                   "ID of the systems catalog in pg_class"
+          t.column :version, :string, index: true, comment: \
+                   "Version of the migration that added the object"
+          t.foreign_key ActiveRecord::Base.schema_migrations_table_name,
+                        column: :version, primary_key: :version,
+                        on_update: :cascade, on_delete: :cascade
+        end
+      end
+      # rubocop: enable Metrics/MethodLength
+
+      # This method is called by a migrator after applying
+      # all migrations in whatever direction.
+      def finalize
+        connection.execute [
+          *create_table,
+          *forget_dropped_objects,
+          *remember_tables,
+          *fill_missed_version,
+        ].join(";")
+      end
+
+      def drop_table
+        connection.drop_table table_name, if_exists: true
+      end
+
+      private
+
+      # List of service tables that shouldn't get into the registry.
+      SERVICE_TABLES = [
+        ActiveRecord::Base.schema_migrations_table_name,
+        ActiveRecord::Base.internal_metadata_table_name,
+        "pg_trunk",
+      ].freeze
+
+      def catalogs
+        connection
+          .execute("SELECT DISTINCT classid::regclass FROM #{table_name}")
+          .map { |item| item["classid"] }
+      end
+
+      # Delete all objects which are absent in system catalogs
+      # (they could be deleted either explicitly, or through
+      # the cascade dependencies clearance).
+      def forget_dropped_objects
+        catalogs.map do |tbl|
+          <<~SQL.squish
+            DELETE FROM #{table_name}
+            WHERE classid = '#{tbl}'::regclass
+              AND oid NOT IN (SELECT oid FROM #{tbl});
+          SQL
+        end
+      end
+
+      # Register all tables known to Rails
+      # along with their indexes, check constraints and foreign keys.
+      # This would let us fetch those objects even though
+      # they were created by native methods of +ActiveRecord+ like
+      # `create_table` etc.
+      def remember_tables
+        names_and_schemas = names_and_schemas_sql
+        return unless names_and_schemas
+
+        <<~SQL.squish
+          WITH
+            tbl AS (
+              SELECT oid FROM pg_class
+              WHERE #{names_and_schemas} AND relkind IN ('r', 'p')
+            ),
+            idx AS (
+              SELECT r.oid
+              FROM pg_class r
+              JOIN pg_index i ON r.oid = i.indexrelid
+              JOIN tbl ON i.indrelid = tbl.oid
+            ),
+            con AS (
+              SELECT c.oid AS oid
+              FROM pg_constraint c
+              JOIN tbl ON c.conrelid = tbl.oid
+              WHERE c.contype IN ('c', 'f')
+            ),
+            obj (oid, classid) AS (
+              SELECT oid, 'pg_class'::regclass FROM tbl
+              UNION
+              SELECT oid, 'pg_class'::regclass FROM idx
+              UNION
+              SELECT oid, 'pg_constraint'::regclass FROM con
+            )
+          INSERT INTO #{table_name} (oid, classid)
+          SELECT oid, classid FROM obj
+          ON CONFLICT DO NOTHING;
+        SQL
+      end
+
+      # Assign the most recent version to new records in `pg_trunk`.
+      def fill_missed_version
+        <<~SQL
+          UPDATE #{table_name} SET version = list.version
+          FROM (
+            SELECT max(version) AS version
+            FROM "#{ActiveRecord::Base.schema_migrations_table_name}"
+          ) list
+          WHERE #{table_name}.version IS NULL;
+        SQL
+      end
+
+      def names_and_schemas_sql
+        (connection.tables - SERVICE_TABLES)
+          .map { |table| QualifiedName.wrap(table) }
+          .group_by(&:namespace)
+          .transform_values { |list| list.map(&:quoted).join(",") }
+          .map { |nsp, tbl| "relnamespace = #{nsp} AND relname IN (#{tbl})" }
+          .join("OR")
+          .presence
+      end
+    end
+  end
+  # rubocop: enable Metrics/ClassLength
+end

data/lib/pg_trunk/core/serializers/array_of_hashes_serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # Cast the attribute value as an array of strings.
+  # It knows how to cast arrays returned by PostgreSQL
+  # as a string like '{USD,EUR,GBP}' into ['USD', 'EUR', 'GBP'].
+  class ArrayOfHashesSerializer < ActiveRecord::Type::Value
+    def cast(value)
+      case value
+      when ::String then JSON.parse(value).map(&:symbolize_keys)
+      when ::NilClass then []
+      when ::Array then value.map(&:to_h)
+      else [value.to_h]
+      end
+    end
+
+    def serialize(value)
+      Array.wrap(value).map { |item| item.to_h.symbolize_keys }
+    end
+  end
+
+  ActiveModel::Type.register(
+    :pg_trunk_array_of_hashes,
+    ArrayOfHashesSerializer,
+  )
+end

data/lib/pg_trunk/core/serializers/array_of_strings_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # Cast the attribute value as an array of strings.
+  # It knows how to cast arrays returned by PostgreSQL
+  # as a string like '{USD,EUR,GBP}' into ['USD', 'EUR', 'GBP'].
+  class ArrayOfStringsSerializer < ActiveRecord::Type::Value
+    def cast(value)
+      case value
+      when ::String
+        value.gsub(/^\{|\}$/, "").split(",")
+      when ::NilClass then []
+      when ::Array then value.map(&:to_s)
+      else [value.to_s]
+      end
+    end
+
+    def serialize(value)
+      value
+    end
+  end
+
+  ActiveModel::Type.register(
+    :pg_trunk_array_of_strings,
+    ArrayOfStringsSerializer,
+  )
+end

data/lib/pg_trunk/core/serializers/array_of_symbols_serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # The same as the array of strings with symbolization at the end
+  class ArrayOfSymbolsSerializer < ActiveRecord::Type::Value
+    def cast(value)
+      case value
+      when ::NilClass then []
+      when ::Symbol then [value]
+      when ::String
+        value.gsub(/^\{|\}$/, "").split(",").map(&:to_sym)
+      when ::Array then value.map { |i| i.to_s.to_sym }
+      else [value.to_s.to_sym]
+      end
+    end
+
+    def serialize(value)
+      value
+    end
+  end
+
+  ActiveModel::Type.register(
+    :pg_trunk_array_of_symbols,
+    ArrayOfSymbolsSerializer,
+  )
+end

data/lib/pg_trunk/core/serializers/array_serializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # Cast the attribute value as an array, not caring about its content.
+  class ArraySerializer < ActiveRecord::Type::Value
+    def cast(value)
+      case value
+      when ::NilClass then []
+      when ::Array then value
+      else [value]
+      end
+    end
+
+    def serialize(value)
+      value
+    end
+  end
+
+  ActiveModel::Type.register(:pg_trunk_array, ArraySerializer)
+end

data/lib/pg_trunk/core/serializers/lowercase_string_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # Cast the attribute value as a non-empty stripped string in lowercase
+  class LowercaseStringSerializer < ActiveRecord::Type::Value
+    def cast(value)
+      value.to_s.presence&.downcase&.strip
+    end
+
+    def serialize(value)
+      value.to_s
+    end
+  end
+
+  ActiveModel::Type.register(
+    :pg_trunk_lowercase_string,
+    LowercaseStringSerializer,
+  )
+end

data/lib/pg_trunk/core/serializers/multiline_text_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # Cast the attribute value as a multiline text
+  # with right-stripped lines and without empty lines.
+  class MultilineTextSerializer < ActiveRecord::Type::Value
+    def cast(value)
+      return if value.blank?
+
+      value.to_s.lines.map(&:strip).reject(&:blank?).join("\n")
+    end
+
+    def serialize(value)
+      value&.to_s
+    end
+  end
+
+  ActiveModel::Type.register(:pg_trunk_multiline_text, MultilineTextSerializer)
+end

data/lib/pg_trunk/core/serializers/qualified_name_serializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # Cast the attribute value as a qualified name.
+  class QualifiedNameSerializer < ActiveRecord::Type::Value
+    TYPE = ::PGTrunk::QualifiedName
+
+    def cast(value)
+      case value
+      when NilClass then nil
+      when TYPE then value
+      else TYPE.wrap(value.to_s)
+      end
+    end
+
+    def serialize(value)
+      value.is_a?(TYPE) ? value.lean : value&.to_s
+    end
+  end
+
+  ActiveModel::Type.register(
+    :pg_trunk_qualified_name,
+    PGTrunk::Serializers::QualifiedNameSerializer,
+  )
+end

data/lib/pg_trunk/core/serializers/symbol_serializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk::Serializers
+  # @private
+  # Cast the attribute value as a symbol.
+  class SymbolSerializer < ActiveRecord::Type::Value
+    def cast(value)
+      return if value.blank?
+      return value if value.is_a?(Symbol)
+      return value.to_sym if value.respond_to?(:to_sym)
+
+      value.to_s.to_sym
+    end
+
+    def serialize(value)
+      value
+    end
+  end
+
+  ActiveModel::Type.register(:pg_trunk_symbol, SymbolSerializer)
+end

data/lib/pg_trunk/core/serializers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PGTrunk
+  # @private
+  # Namespace for the gem-specific activemodel serializers
+  module Serializers
+    require_relative "serializers/array_serializer"
+    require_relative "serializers/array_of_hashes_serializer"
+    require_relative "serializers/array_of_strings_serializer"
+    require_relative "serializers/array_of_symbols_serializer"
+    require_relative "serializers/lowercase_string_serializer"
+    require_relative "serializers/multiline_text_serializer"
+    require_relative "serializers/qualified_name_serializer"
+    require_relative "serializers/symbol_serializer"
+  end
+end

data/lib/pg_trunk/core/validators/all_items_valid_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# @private
+# Ensure that all items in the array are valid
+class PGTrunk::AllItemsValidValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    Array.wrap(value).each.with_index.map do |item, index|
+      item.errors.messages.each do |name, list|
+        list.each do |message|
+          record.errors.add :base, "#{attribute}[#{index}]: #{name} #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/pg_trunk/core/validators/difference_validator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# @private
+# Ensure that an attribute is different from another one
+class PGTrunk::DifferenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    another_name = options.fetch(:from)
+    another_value = record.send(another_name).presence
+
+    case another_value
+    when PGTrunk::QualifiedName
+      return unless value.maybe_eq?(another_value)
+    else
+      return unless value == another_value
+    end
+
+    record.errors.add attribute, "must be different from the #{another_name}"
+  end
+end

data/lib/pg_trunk/core/validators.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module PGTrunk
+  # @private
+  # Namespace for the gem-specific activemodel validators
+  module Validators
+    require_relative "validators/all_items_valid_validator"
+    require_relative "validators/difference_validator"
+  end
+end

data/lib/pg_trunk/core.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# This class loads the base mechanics of the gem
+# isolated in the corresponding folder.
+
+# nodoc
+module PGTrunk
+  require_relative "core/adapters/postgres"
+  require_relative "core/railtie"
+  require_relative "core/qualified_name"
+  require_relative "core/registry"
+  require_relative "core/serializers"
+  require_relative "core/validators"
+  require_relative "core/operation"
+  require_relative "core/dependencies_resolver"
+
+  # @private
+  def database
+    Adapters::Postgres.new
+  end
+end

data/lib/pg_trunk/generators.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "version"
+require_relative "core/serializers"
+require_relative "core/operation"
+require_relative "core/generators"
+require_relative "operations"

data/lib/pg_trunk/operations/check_constraints/add_check_constraint.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#add_check_constraint(table, expression = nil, **options, &block)
+# Add a check constraint to the table
+#
+# @param [#to_s] table (nil) The qualified name of the table
+# @param [#to_s] expression (nil) The SQL expression
+# @option [#to_s] :name (nil) The optional name of the constraint
+# @option [Boolean] :inherit (true) If the constraint should be inherited by subtables
+# @option [#to_s] :comment (nil) The comment describing the constraint
+# @yield [Proc] the block with the constraint's definition
+# @yieldparam The receiver of methods specifying the constraint
+#
+# The name of the new constraint can be set explicitly
+#
+#   add_check_constraint :users, "length(phone) > 10",
+#                        name: "phone_is_long_enough",
+#                        inherit: false,
+#                        comment: "Phone is 10+ chars long"
+#
+# The name can also be skipped (it will be generated by default):
+#
+#   add_check_constraint :users, "length(phone) > 1"
+#
+# The block syntax can be used for any argument as usual:
+#
+#   add_check_constraint do |c|
+#     c.table "users"
+#     c.expression "length(phone) > 10"
+#     c.name "phone_is_long_enough"
+#     c.inherit false
+#     c.comment "Phone is 10+ chars long"
+#   end
+#
+# The operation is always reversible.
+
+module PGTrunk::Operations::CheckConstraints
+  # @private
+  class AddCheckConstraint < Base
+    # The operation is used by the generator `rails g check_constraint`
+    generates_object :check_constraint
+
+    validates :expression, presence: true
+    validates :if_exists, :new_name, :force, absence: true
+
+    from_sql do
+      <<~SQL
+        SELECT
+          c.oid,
+          c.conname AS name,
+          c.connamespace::regnamespace AS schema,
+          r.relnamespace::regnamespace || '.' || r.relname AS "table",
+          (
+            NOT c.connoinherit
+          ) AS inherit,
+          (
+            regexp_match(
+              pg_get_constraintdef(c.oid),
+              '^CHECK [(][(](.+)[)][)]( NO INHERIT)?$'
+            )
+          )[1] AS expression,
+          d.description AS comment
+        FROM pg_constraint c
+          JOIN pg_class r ON r.oid = c.conrelid
+          LEFT JOIN pg_description d ON c.oid = d.objoid
+        WHERE c.contype = 'c';
+      SQL
+    end
+
+    def to_sql(_version)
+      [add_constraint, *add_comment, register_constraint].compact.join(" ")
+    end
+
+    def invert
+      DropCheckConstraint.new(**to_h)
+    end
+
+    private
+
+    def add_constraint
+      sql = "ALTER TABLE #{table.to_sql} ADD CONSTRAINT #{name.name.inspect}"
+      sql << " CHECK (#{expression})"
+      sql << " NO INHERIT" unless inherit
+      sql << ";"
+    end
+
+    def add_comment
+      return if comment.blank?
+
+      <<~SQL
+        COMMENT ON CONSTRAINT #{name.lean.inspect} ON #{table.to_sql}
+        IS $comment$#{comment}$comment$;
+      SQL
+    end
+
+    # Rely on the fact the (schema.table, schema.name) is unique
+    def register_constraint
+      <<~SQL
+        INSERT INTO pg_trunk (oid, classid)
+          SELECT c.oid, 'pg_constraint'::regclass
+          FROM pg_constraint c JOIN pg_class r ON r.oid = c.conrelid
+          WHERE r.relname = #{table.quoted}
+            AND r.relnamespace = #{table.namespace}
+            AND c.conname = #{name.quoted}
+        ON CONFLICT DO NOTHING;
+      SQL
+    end
+  end
+end

data/lib/pg_trunk/operations/check_constraints/base.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::CheckConstraints
+  # @abstract
+  # @private
+  # Base class for operations with check constraints
+  class Base < PGTrunk::Operation
+    # All attributes that can be used by check-related commands
+    attribute :expression, :string
+    attribute :inherit, :boolean, default: true
+    attribute :table, :pg_trunk_qualified_name
+
+    # Generate missed name from table & expression
+    after_initialize { self.name = generated_name if name.blank? }
+
+    # Ensure correctness of present values
+    # The table must be defined because the name only
+    # is not enough to identify the constraint.
+    validates :if_not_exists, absence: true
+    validates :table, presence: true
+
+    # By default foreign keys are sorted by tables and names.
+    def <=>(other)
+      return unless other.is_a?(self.class)
+
+      result = table <=> other.table
+      result.zero? ? super : result
+    end
+
+    # Support `table` and `expression` in positional arguments
+    # @example
+    #   add_check_constraint :users, "length(phone) == 10", **opts
+    ruby_params :table, :expression
+
+    # Snippet to be used in all operations with check constraints
+    ruby_snippet do |s|
+      s.ruby_param(table.lean) if table.present?
+      s.ruby_param(expression) if expression.present?
+      s.ruby_param(if_exists: true) if if_exists
+      s.ruby_param(inherit: false) if inherit&.== false
+      s.ruby_param(name: name.lean) if custom_name?
+      s.ruby_param(to: new_name.lean) if custom_name?(new_name)
+      s.ruby_param(comment: comment) if comment.present?
+    end
+
+    private
+
+    # *************************************************************************
+    # Helpers for operation definitions
+    # *************************************************************************
+
+    def generated_name
+      return @generated_name if instance_variable_defined?(:@generated_name)
+
+      @generated_name = begin
+        return if table.blank? || expression.blank?
+
+        PGTrunk::QualifiedName.new(
+          nil,
+          PGTrunk.database.check_constraint_name(table.lean, expression),
+        )
+      end
+    end
+
+    def custom_name?(qname = name)
+      qname&.differs_from?(/^chk_rails_\w+$/)
+    end
+  end
+end