pg_trunk 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98c9050bc62e8f9a33f87ff77a836189fca018a968ff1fd487f1e5b613b1278f
-  data.tar.gz: 30bcc2a1d61cc3343a95e752d8307c20b1326b57969ac0479a3e4ef161026747
+  metadata.gz: c7e02c0f3a19350a502afda3e8697421912161b9bd800eb6302738cc623eb3eb
+  data.tar.gz: c0108a41cabe1fd1eebc0695e222ceafeb27c195b9c8fe2766e1f4ced4142c63
 SHA512:
-  metadata.gz: a4ba64e08cb9a12ce958e1a4a13a88370e4a20e8fe25cf9da19731c5e77ea8d952decabaebd89c6c0af545f34e955f274a768ad28282345e0365ef57f314d69b
-  data.tar.gz: 62289de65886d00d28a979149909839f237afdd9e1144f61710306f4da4258e9487da36e07ef21f46e90b86f63cd6b18a17db59317728eac56ce37524cdbc60a
+  metadata.gz: 7af9d03c65275a700408841a032cf2f074349943a8d131e54d5dff4f467b9e4bb3fadce657d70469ec2cb1471b41578bef68fc91a92771429d3da84b648161f8
+  data.tar.gz: 9a47edbac23bffb1db4c74f0108f42c06c5e9d7aa28b5d213fed05f908a8e738114db1ad4c38557fde7db7e2d514cabf6646d65a8193c7e5bf664b4d20bc38ff

data/.github/workflows/ci.yml

@@ -58,25 +58,14 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
 
-      - name: Install Ruby ${{ matrix.ruby }}
-        uses: ruby/setup-ruby@v1.61.1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-
       - name: Install dependent libraries
         run: sudo apt-get install libpq-dev
 
-      - name: Generate lockfile
-        run: bundle lock
-
-      - name: Cache dependencies
-        uses: actions/cache@v1
+      - name: Install Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1.61.1
         with:
-          path: vendor/bundle
-          key: bundle-${{ hashFiles('Gemfile.lock') }}
-
-      - name: Set up PGTrunk
-        run: bin/setup
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true # 'bundle install' and cache
 
       - name: Check code style
         run: bundle exec rubocop

data/CHANGELOG.md

@@ -4,6 +4,26 @@ The noteworthy changes for each PGTrunk version are included here.
 The format is based on [Keep a Changelog] and this project adheres to [Semantic Versioning].
 For a complete changelog, see the [commits] for each version via the version links.
 
+## [0.2.0] (2022-01-26)
+
+* Add support for sequences (nepalez)
+* Fix inheritance of attribute aliases (nepalez)
+* Fix documentation for rules (nepalez)
+
+## [0.1.3] (2022-01-20)
+
+* Add support for rules (nepalez)
+* Fix CI/CD flow (olleolleolle)
+* Fix documentation (nepalez)
+
+## [0.1.2] (2022-01-17)
+
+* Fix registry of custom types (nepalez)
+
+## [0.1.1] (2022-01-16)
+
+* Fix inline documentation for methods added to ActiveRecord::Migration (nepalez)
+
 ## [0.1.0] (2022-01-14)
 
 This is a first public release (nepalez)
@@ -24,6 +44,7 @@ Supported features:
 - composite types
 - domains types
 
+[0.1.1]: https://github.com/nepalez/pg_trunk/releases/tag/v0.1.1
 [0.1.0]: https://github.com/nepalez/pg_trunk/releases/tag/v0.1.0
 
 [Keep a Changelog]: http://keepachangelog.com/

data/README.md

@@ -72,6 +72,8 @@ As of today we support creation, modification and dropping the following objects
 - enumerable types
 - composite types
 - domains types
+- rules
+- sequences
 
 For `tables` and `indexes` we reuse the ActiveRecord's native methods.
 For `check constraints` and `foreign keys` we support both the native definitions inside the table
@@ -88,7 +90,7 @@ The gem is targeted to support PostgreSQL-specific features, that's why we won't
 ## Documentation
 
 The gem provides a lot of additional methods to create, rename, change a drop various objects.
-You can find the necessary details in the gem's [wiki].
+You can find the necessary details [here](https://rubydoc.info/gems/pg_trunk/ActiveRecord/Migration).
 
 ## Installation
 

data/lib/pg_trunk/core/operation/attributes.rb

@@ -51,7 +51,7 @@ class PGTrunk::Operation
       end
 
       def inherited(klass)
-        klass.instance_variable_set(:@attr_aliases, attr_aliases)
+        klass.instance_variable_set(:@attr_aliases, attr_aliases.dup)
         super
       end
     end

data/lib/pg_trunk/core/railtie/custom_types.rb

@@ -12,22 +12,21 @@ module PGTrunk
     end
 
     def enable_pg_trunk_types
-      execute(<<~SQL).each { |item| enable_pg_trunk_type item["name"] }
+      execute(<<~SQL).each { |item| enable_pg_trunk_type(**item.symbolize_keys) }
         SELECT (
           CASE
           WHEN t.typnamespace = 'public'::regnamespace THEN t.typname
           ELSE t.typnamespace::regnamespace || '.' || t.typname
           END
-        ) AS name
+        ) AS name, t.oid
         FROM pg_trunk e JOIN pg_type t ON t.oid = e.oid
         WHERE e.classid = 'pg_type'::regclass
       SQL
     end
 
-    def enable_pg_trunk_type(type)
-      type = type.to_s
-      CustomTypes.known << type
-      type_map.register_type(type, TYPE.new(type)) unless type_map.key?(type)
+    def enable_pg_trunk_type(oid:, name:)
+      CustomTypes.known << name
+      type_map.register_type(oid.to_i, TYPE.new(name.to_s))
     end
 
     def valid_type?(type)

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

@@ -1,39 +1,48 @@
 # 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"
+# @!parse
+#   class ActiveRecord::Migration
+#     # 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 options [#to_s] :name (nil) The optional name of the constraint
+#     # @option options [Boolean] :inherit (true) If the constraint should be inherited by subtables
+#     # @option options [#to_s] :comment (nil) The comment describing the constraint
+#     # @yield [c] the block with the constraint's definition
+#     # @yieldparam Object receiver of methods specifying the constraint
+#     # @return [void]
+#     #
+#     # The name of the new constraint can be set explicitly
+#     #
+#     # ```ruby
+#     # 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):
+#     #
+#     # ```ruby
+#     # add_check_constraint :users, "length(phone) > 1"
+#     # ```
+#     #
+#     # The block syntax can be used for any argument as usual:
+#     #
+#     # ```ruby
+#     # 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.
+#     def add_check_constraint(table, expression = nil, **options, &block); end
 #   end
-#
-# The operation is always reversible.
-
 module PGTrunk::Operations::CheckConstraints
   # @private
   class AddCheckConstraint < Base

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

@@ -1,46 +1,57 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#drop_check_constraint(table, expression = nil, **options, &block)
-# Remove a check constraint from the table
-#
-# @param [#to_s] table (nil) The qualified name of the table
-# @param [#to_s] expression (nil) The SQL expression
-# @option [Boolean] :if_exists (false) Suppress the error when the constraint is absent
-# @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
-#
-# Definition for the `drop_check_constraint` operation
-#
-# The constraint can be identified by the table and explicit name
-#
-#   drop_check_constraint :users, name: "phone_is_long_enough"
-#
-# Alternatively the name can be got from the expression.
-# Be careful! the expression must have exactly the same form
-# as stored in the database:
-#
-#   drop_check_constraint :users, "length((phone::text) > 10)"
-#
-# To made operation reversible the expression must be provided:
-#
-#   drop_check_constraint "users" do |c|
-#     c.expression "length((phone::text) > 10)"
-#     c.inherit false
-#     c.comment "The phone is 10+ chars long"
+# @!parse
+#   class ActiveRecord::Migration
+#     # Remove a check constraint from the table
+#     #
+#     # @param [#to_s] table (nil) The qualified name of the table
+#     # @param [#to_s] expression (nil) The SQL expression
+#     # @option options [Boolean] :if_exists (false) Suppress the error when the constraint is absent
+#     # @option options [#to_s] :name (nil) The optional name of the constraint
+#     # @option options [Boolean] :inherit (true) If the constraint should be inherited by subtables
+#     # @option options [#to_s] :comment (nil) The comment describing the constraint
+#     # @yield [c] the block with the constraint's definition
+#     # @yieldparam Object receiver of methods specifying the constraint
+#     # @return [void]
+#     #
+#     # Definition for the `drop_check_constraint` operation
+#     #
+#     # The constraint can be identified by the table and explicit name
+#     #
+#     # ```ruby
+#     # drop_check_constraint :users, name: "phone_is_long_enough"
+#     # ```
+#     #
+#     # Alternatively the name can be got from the expression.
+#     # Be careful! the expression must have exactly the same form
+#     # as stored in the database:
+#     #
+#     # ```ruby
+#     # drop_check_constraint :users, "length((phone::text) > 10)"
+#     # ```
+#     #
+#     # To made operation reversible the expression must be provided:
+#     #
+#     # ```ruby
+#     # drop_check_constraint "users" do |c|
+#     #   c.expression "length((phone::text) > 10)"
+#     #   c.inherit false
+#     #   c.comment "The phone is 10+ chars long"
+#     # end
+#     # ```
+#     #
+#     # The operation can be called with `if_exists` option.
+#     #
+#     # ```ruby
+#     # drop_check_constraint :users,
+#     #                       name: "phone_is_long_enough",
+#     #                       if_exists: true
+#     # ```
+#     #
+#     # In this case the operation is always irreversible due to
+#     # uncertainty of the previous state of the database.
+#     def drop_check_constraint(table, expression = nil, **options, &block); end
 #   end
-#
-# The operation can be called with `if_exists` option.
-#
-#   drop_check_constraint :users,
-#                         name: "phone_is_long_enough",
-#                         if_exists: true
-#
-# In this case the operation is always irreversible due to
-# uncertainty of the previous state of the database.
-
 module PGTrunk::Operations::CheckConstraints
   # @private
   class DropCheckConstraint < Base

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

@@ -1,35 +1,44 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#rename_check_constraint(table, expression = nil, **options, &block)
-# Rename a check constraint
-#
-# @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 current name of the constraint
-# @option [#to_s] :to (nil) The new name for the constraint
-# @yield [Proc] the block with the constraint's definition
-# @yieldparam The receiver of methods specifying the constraint
-#
-# A constraint can be identified by the table and explicit name
-#
-#   rename_check_constraint :users,
-#                           name: "phone_is_long_enough",
-#                           to: "phones.long_enough"
-#
-# Alternatively the name can be got from the expression.
-# Be careful! the expression must have exactly the same form
-# as stored in the database:
-#
-#   rename_check_constraint :users, "length((phone::text) > 10)",
-#                           to: "long_enough"
-#
-# The name can be reset to auto-generated when
-# the `:to` option is missed or blank:
-#
-#   rename_check_constraint :users, "phone_is_long_enough"
-#
-# The operation is always reversible.
-
+# @!parse
+#   class ActiveRecord::Migration
+#     # Rename a check constraint
+#     #
+#     # @param [#to_s] table (nil) The qualified name of the table
+#     # @param [#to_s] expression (nil) The SQL expression
+#     # @option options [#to_s] :name (nil) The current name of the constraint
+#     # @option options [#to_s] :to (nil) The new name for the constraint
+#     # @yield [c] the block with the constraint's definition
+#     # @yieldparam Object receiver of methods specifying the constraint
+#     # @return [void]
+#     #
+#     # A constraint can be identified by the table and explicit name
+#     #
+#     # ```ruby
+#     # rename_check_constraint :users,
+#     #                         name: "phone_is_long_enough",
+#     #                         to: "phones.long_enough"
+#     # ```
+#     #
+#     # Alternatively the name can be got from the expression.
+#     # Be careful! the expression must have exactly the same form
+#     # as stored in the database:
+#     #
+#     # ```ruby
+#     # rename_check_constraint :users, "length((phone::text) > 10)",
+#     #                         to: "long_enough"
+#     # ```
+#     #
+#     # The name can be reset to auto-generated when
+#     # the `:to` option is missed or blank:
+#     #
+#     # ```ruby
+#     # rename_check_constraint :users, "phone_is_long_enough"
+#     # ```
+#     #
+#     # The operation is always reversible.
+#     def rename_check_constraint(table, expression = nil, **options, &block); end
+#   end
 module PGTrunk::Operations::CheckConstraints
   # @private
   class RenameCheckConstraint < Base

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

@@ -1,26 +1,33 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#validate_check_constraint(table, expression = nil, **options, &block)
-# Validate an invalid check constraint
-#
-# @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
-# @yield [Proc] the block with the constraint's definition
-# @yieldparam The receiver of methods specifying the constraint
-#
-# The invalid constraint can be identified by table and explicit name:
-#
-#   validate_check_constraint :users, name: "phone_is_long_enough"
-#
-# Alternatively it can be specified by expression. In this case
-# you must ensure the expression has the same form as it is stored
-# in the database (after parsing the source).
-#
-#   validate_check_constraint :users, "length((phone::text) > 10)"
-#
-# Notice that it is invertible but the inverted operation does nothing.
-
+# @!parse
+#   class ActiveRecord::Migration
+#     # Validate an invalid check constraint
+#     #
+#     # @param [#to_s] table (nil) The qualified name of the table
+#     # @param [#to_s] expression (nil) The SQL expression
+#     # @option options [#to_s] :name (nil) The optional name of the constraint
+#     # @yield [c] the block with the constraint's definition
+#     # @yieldparam Object receiver of methods specifying the constraint
+#     # @return [void]
+#     #
+#     # The invalid constraint can be identified by table and explicit name:
+#     #
+#     # ```ruby
+#     # validate_check_constraint :users, name: "phone_is_long_enough"
+#     # ```
+#     #
+#     # Alternatively it can be specified by expression. In this case
+#     # you must ensure the expression has the same form as it is stored
+#     # in the database (after parsing the source).
+#     #
+#     # ```ruby
+#     # validate_check_constraint :users, "length((phone::text) > 10)"
+#     # ```
+#     #
+#     # Notice that it is invertible but the inverted operation does nothing.
+#     def validate_check_constraint(table, expression = nil, **options, &block); end
+#   end
 module PGTrunk::Operations::CheckConstraints
   # @private
   class ValidateCheckConstraint < Base

data/lib/pg_trunk/operations/composite_types/change_composite_type.rb

@@ -1,56 +1,65 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#change_composite_type(name, **options, &block)
-# Modify a composite type
-#
-# @param [#to_s] name (nil) The qualified name of the type
-# @option [Symbol] :force (:restrict) How to process dependent objects (`:cascade` or `:restrict`)
-# @option [#to_s] :comment (nil) The comment describing the constraint
-# @yield [Proc] the block with the type's definition
-# @yieldparam The receiver of methods specifying the type
-#
-# The operation can be used to add, drop, rename or change columns.
-# The comment can be changed as well.
-#
-# Providing a type "paint.colored_point":
-#
-#   create_composite_type "paint.colored_point" do |t|
-#     t.column "color", "text", collation: "en_US"
-#     t.column "x", "integer"
-#     t.column "z", "integer"
+# @!parse
+#   class ActiveRecord::Migration
+#     # Modify a composite type
+#     #
+#     # @param [#to_s] name (nil) The qualified name of the type
+#     # @option options [Symbol] :force (:restrict) How to process dependent objects (`:cascade` or `:restrict`)
+#     # @option options [#to_s] :comment (nil) The comment describing the constraint
+#     # @yield [t] the block with the type's definition
+#     # @yieldparam Object receiver of methods specifying the type
+#     # @return [void]
+#     #
+#     # The operation can be used to add, drop, rename or change columns.
+#     # The comment can be changed as well.
+#     #
+#     # Providing a type "paint.colored_point":
+#     #
+#     # ```ruby
+#     # create_composite_type "paint.colored_point" do |t|
+#     #   t.column "color", "text", collation: "en_US"
+#     #   t.column "x", "integer"
+#     #   t.column "z", "integer"
+#     # end
+#     # ```
+#     #
+#     # After the following change:
+#     #
+#     # ```ruby
+#     # change_composite_type "paint.colored_point" do |t|
+#     #   t.change_column "color", "text", collation: "ru_RU", from_collation: "en_US"
+#     #   t.change_column "x", "bigint", from_type: "integer"
+#     #   t.drop_column "z", "integer"
+#     #   t.add_column "Y", "bigint"
+#     #   t.rename_column "x", to: "X"
+#     #   t.comment "2D point with a color", from: "2D point"
+#     # end
+#     # ```
+#     #
+#     # The definition became:
+#     #
+#     # ```ruby
+#     # create_composite_type "paint.colored_point" do |t|
+#     #   t.column "color", "text", collation: "ru_RU"
+#     #   t.column "X", "bigint"
+#     #   t.column "Y", "integer"
+#     # end
+#     # ```
+#     #
+#     # Notice, that all renames will be done AFTER other changes,
+#     # so in `change_column` you should use the old names.
+#     #
+#     # In several cases the operation is not invertible:
+#     #
+#     # - when a column was dropped
+#     # - when `force: :cascade` option is used (to update
+#     #   objects that use the type)
+#     # - when `if_exists: true` is added to the `drop_column` clause
+#     # - when a previous state of the column type, collation or comment
+#     #   is not specified.
+#     def change_composite_type(name, **options, &block); end
 #   end
-#
-# After the following change:
-#
-#   change_composite_type "paint.colored_point" do |t|
-#     t.change_column "color", "text", collation: "ru_RU", from_collation: "en_US"
-#     t.change_column "x", "bigint", from_type: "integer"
-#     t.drop_column "z", "integer"
-#     t.add_column "Y", "bigint"
-#     t.rename_column "x", to: "X"
-#     t.comment "2D point with a color", from: "2D point"
-#   end
-#
-# The definition became:
-#
-#   create_composite_type "paint.colored_point" do |t|
-#     t.column "color", "text", collation: "ru_RU"
-#     t.column "X", "bigint"
-#     t.column "Y", "integer"
-#   end
-#
-# Notice, that all renames will be done AFTER other changes,
-# so in `change_column` you should use the old names.
-#
-# In several cases the operation is not invertible:
-#
-# - when a column was dropped
-# - when `force: :cascade` option is used (to update
-#   objects that use the type)
-# - when `if_exists: true` is added to the `drop_column` clause
-# - when a previous state of the column type, collation or comment
-#   is not specified.
-
 module PGTrunk::Operations::CompositeTypes
   # @private
   class ChangeCompositeType < Base

data/lib/pg_trunk/operations/composite_types/create_composite_type.rb

@@ -1,25 +1,29 @@
 # frozen_string_literal: false
 
-# @!method ActiveRecord::Migration#create_composite_type(name, **options, &block)
-# Create a composite type
-#
-# @param [#to_s] name (nil) The qualified name of the type
-# @option [#to_s] :comment (nil) The comment describing the constraint
-# @yield [Proc] the block with the type's definition
-# @yieldparam The receiver of methods specifying the type
-#
-# @example
-#   create_composite_type "paint.colored_point" do |d|
-#     d.column "x", "integer"
-#     d.column "y", "integer"
-#     d.column "color", "text", collation: "en_US"
-#     d.comment <<~COMMENT
-#       2D point with color
-#     COMMENT
+# @!parse
+#   class ActiveRecord::Migration
+#     # Create a composite type
+#     #
+#     # @param [#to_s] name (nil) The qualified name of the type
+#     # @option options [#to_s] :comment (nil) The comment describing the constraint
+#     # @yield [t] the block with the type's definition
+#     # @yieldparam Object receiver of methods specifying the type
+#     # @return [void]
+#     #
+#     # ```ruby
+#     # create_composite_type "paint.colored_point" do |d|
+#     #   d.column "x", "integer"
+#     #   d.column "y", "integer"
+#     #   d.column "color", "text", collation: "en_US"
+#     #   d.comment <<~COMMENT
+#     #     2D point with color
+#     #   COMMENT
+#     # end
+#     # ```
+#     #
+#     # It is always reversible.
+#     def create_composite_type(name, **options, &block); end
 #   end
-#
-# It is always reversible.
-
 module PGTrunk::Operations::CompositeTypes
   # @private
   class CreateCompositeType < Base