enum_kit 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0edccc6b488902ea7344f63e24014979d60f2a315c79335fc959c7cfeafb1473
-  data.tar.gz: 2776e409ad4108dfaf9b504d6cdb3d43cafe3368e9889d05f27635f8240c33d6
+  metadata.gz: 6f5949293c0b433b8a014dd718bdb0db6f65b13293bc3c781d51296e13a3023d
+  data.tar.gz: 5d8e7e994ec2f47c932fb120e1bb9373d6b9d64ab9380cbba98de58483377004
 SHA512:
-  metadata.gz: 7f41dc0fd5399088b5d5cdc02fb2bd48fd0a1c3ff3b4fdb44d53920d9c6d4b12ece952c2d6ee9c3174423bd79d3f96b7babd1e7a107315acb35ea58a6aa8cda5
-  data.tar.gz: c43cd3f3a197c828d958de2f5374d6a8d98d1ff1d6f381ec8d1265753d081682cca917af8cd220317ca0014313812102bfe6cde7e999913ab161fac480002395
+  metadata.gz: 281be07f6004fc567ceb889b1bf63574e08ba8a0e3f250a098b37ba19d9e035718e75993248cc9e4a9d80d1640a5453b71ee4c89848a9f125bae84db16ea046b
+  data.tar.gz: 6ecf20f2cf802b611c6a5604dd5940962448b70bb3816668f596f81d6c0b46e5292ebf032eeb562c74cd6ea0a78d17623d39280e6e6b73bf25e4c42f38f90b99

data/.travis.yml

@@ -1,6 +1,9 @@
 language: ruby
 rvm:
   - 2.6.5
+gemfile:
+  - travis/gemfiles/5.2.gemfile
+  - travis/gemfiles/6.0.gemfile
 services:
   - postgresql
 before_install:
@@ -8,6 +11,13 @@ before_install:
   - gem install bundler
 before_script:
   - psql -c 'CREATE DATABASE enum_kit_test;' -U postgres
+addons:
+  postgresql: 10
+  apt:
+    packages:
+      - postgresql-10
+      - postgresql-client-10
 env:
   global:
     - DATABASE_URL="postgresql://127.0.0.1:5432/enum_kit_test"
+    - RSPEC_DEFAULT_FORMATTER=doc

data/README.md

@@ -1,5 +1,7 @@
 # EnumKit
 
+[![Build Status](https://travis-ci.org/NialtoServices/enum_kit.svg?branch=master)](https://travis-ci.org/NialtoServices/enum_kit)
+
 EnumKit provides native support for PostgreSQL enums in Ruby on Rails projects.
 
 ## Installation

data/config.ru

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "rubygems"
-require "bundler"
+require 'rubygems'
+require 'bundler'
 
 Bundler.require :default, :development
 

data/enum_kit.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
 
   spec.metadata['yard.run'] = 'yri'
 
-  spec.add_runtime_dependency 'activerecord',  '>= 4.0.0'
-  spec.add_runtime_dependency 'activesupport', '>= 4.0.0'
+  spec.add_runtime_dependency 'activerecord',  '>= 5.2.0'
+  spec.add_runtime_dependency 'activesupport', '>= 5.2.0'
   spec.add_runtime_dependency 'pg'
 
   spec.add_development_dependency 'bundler',     '~> 2.0'

data/lib/enum_kit/active_record_extensions/connection_adapters/postgresql/column_dumper.rb

@@ -19,7 +19,7 @@ module EnumKit
           #
           def prepare_column_options(column)
             spec = super
-            spec[:name] = column.sql_type.inspect if column.type == :enum
+            spec[:enum_type] = column.sql_type.inspect if column.type == :enum
             spec
           end
         end

data/lib/enum_kit/active_record_extensions/connection_adapters/postgresql/schema_dumper.rb

@@ -19,7 +19,7 @@ module EnumKit
           #
           def prepare_column_options(column)
             spec = super
-            spec[:name] = column.sql_type.inspect if column.type == :enum
+            spec[:enum_type] = column.sql_type.inspect if column.type == :enum
             spec
           end
         end

data/lib/enum_kit/active_record_extensions/connection_adapters/postgresql_adapter.rb

@@ -30,14 +30,14 @@ module EnumKit
         # @return [Hash] The enum types available in the database.
         #
         def enums
-          @enums ||= select_all(ENUM_QUERY.tr("\n", ' ').strip).each_with_object({}) do |row, enums|
+          select_all(ENUM_QUERY.tr("\n", ' ').strip).each_with_object({}) do |row, enums|
             enums[row['typname'].to_sym] = row['values'].split("\t\t")
           end
         end
 
         # Create a new enum type in the database.
         #
-        # @param name   [Symbol] The name of the new enum type.
+        # @param name   [Symbol] The enum's name.
         # @param values [Array]  The enum's acceptable values.
         #
         def create_enum(name, values)
@@ -47,27 +47,88 @@ module EnumKit
           execute "CREATE TYPE #{name} AS ENUM #{EnumKit.sqlize(values)}"
         end
 
+        # Rename an existing enum type.
+        #
+        # @param current_name [Symbol] The enum's current name.
+        # @param new_name     [Symbol] The enum's new name.
+        #
+        def rename_enum(current_name, new_name)
+          current_name = EnumKit.sanitize_name!(current_name)
+          new_name     = EnumKit.sanitize_name!(new_name)
+
+          execute "ALTER TYPE #{current_name} RENAME TO #{new_name}"
+        end
+
         # Drop an existing enum type from the database.
         #
-        # @param name [Symbol] The name of the existing enum type.
+        # @param name [Symbol] The enum's name.
         #
         def drop_enum(name)
+          name = EnumKit.sanitize_name!(name)
+
           execute "DROP TYPE #{name}"
         end
 
+        # Add a new value to an enum type in the database.
+        #
+        # Note that you can't specify both :before and :after.
+        #
+        # @param name   [Symbol]        The enum's name.
+        # @param value  [String|Symbol] The value to add.
+        # @param after  [String|Symbol] An existing value after which the new value should be inserted.
+        # @param before [String|Symbol] An existing value before which the new value should be inserted.
+        #
+        def add_enum_value(name, value, after: nil, before: nil)
+          name  = EnumKit.sanitize_name!(name)
+          value = EnumKit.sanitize_value!(value)
+
+          statement = "ALTER TYPE #{name} ADD VALUE #{EnumKit.sqlize(value)}"
+
+          raise ArgumentError, "You can't specify both :before and :after" if before && after
+
+          statement += " AFTER #{EnumKit.sqlize(EnumKit.sanitize_value!(after))}"   if after
+          statement += " BEFORE #{EnumKit.sqlize(EnumKit.sanitize_value!(before))}" if before
+
+          execute(statement)
+        end
+
+        # Rename a value within an enum type in the database.
+        #
+        # @param name          [Symbol]        The enum's name.
+        # @param current_value [String|Symbol] The enum value's current name.
+        # @param new_value     [String|Symbol] The enum value's new name.
+        #
+        def rename_enum_value(name, current_name, new_name)
+          ensure_renaming_enum_values_is_supported!
+
+          name         = EnumKit.sanitize_name!(name)
+          current_name = EnumKit.sanitize_value!(current_name)
+          new_name     = EnumKit.sanitize_value!(new_name)
+
+          execute "ALTER TYPE #{name} RENAME VALUE #{EnumKit.sqlize(current_name)} TO #{EnumKit.sqlize(new_name)}"
+        end
+
         # :nodoc:
         #
         def migration_keys
-          super + [:name]
+          super + [:enum_type]
         end
 
         # :nodoc:
         #
-        def prepare_column_options(column, types)
-          spec = super(column, types)
-          spec[:name] = column.cast_type.type.inspect if column.type == :enum
+        def prepare_column_options(column)
+          spec = super
+          spec[:enum_type] = column.sql_type.inspect if column.type == :enum
           spec
         end
+
+        # Raise an exception if the active PostgreSQL version doesn't support renaming enum values.
+        #
+        def ensure_renaming_enum_values_is_supported!
+          return if ActiveRecord::Base.connection.postgresql_version >= 100_000
+
+          raise NotImplementedError, 'PostgreSQL 10.0+ is required to enable renaming of enum values.'
+        end
       end
     end
   end

data/lib/enum_kit/active_record_extensions/migration/command_recorder.rb

@@ -12,33 +12,72 @@ module EnumKit
       # :nodoc:
       #
       module CommandRecorder
-        # :nodoc:
+        # Record the creation of an enum type.
         #
         def create_enum(*args)
           record(:create_enum, args)
         end
 
-        # :nodoc:
+        # Record the renaming of an enum type.
+        #
+        def rename_enum(*args)
+          record(:rename_enum, args)
+        end
+
+        # Record the deletion of an enum type.
         #
         def drop_enum(*args)
           record(:drop_enum, args)
         end
 
-        # :nodoc:
+        # Record the addition of a value to an enum type.
+        #
+        def add_enum_value(*args)
+          record(:add_enum_value, args)
+        end
+
+        # Record the renaming of a value in an enum type.
+        #
+        def rename_enum_value(*args)
+          record(:rename_enum_value, args)
+        end
+
+        # Invert the creation of an enum type by deleting it.
         #
         def invert_create_enum(args)
           record(:drop_enum, args.first)
         end
 
-        # :nodoc:
+        # Invert the renaming of an enum by renaming it back to the previous name.
+        #
+        def invert_rename_enum(args)
+          record(:rename_enum, args.reverse)
+        end
+
+        # Invert the deletion of an enum type by creating it.
+        #
+        # Note that `drop_enum` can only be reversed if given a collection of values to call `create_enum` with as the
+        # previously deleted enum values cannot be automatically determined.
         #
         def invert_drop_enum(args)
           unless args.length > 1
-            raise ::ActiveRecord::IrreversibleMigration, 'drop_enum is only reversible if given an Array of values.'
+            raise ActiveRecord::IrreversibleMigration, 'drop_enum is only reversible if given an Array of values.'
           end
 
           record(:create_enum, args)
         end
+
+        # Invert the addition of a value to an enum type by removing the value.
+        #
+        def invert_add_enum_value(_args)
+          raise ActiveRecord::IrreversibleMigration, 'add_enum_value is not reversible.'
+        end
+
+        # Invert the renaming of an enum's value by renaming it back to the previous value.
+        #
+        def invert_rename_enum_value(args)
+          record(:rename_enum_value, args[0], args[2], args[1])
+        end
       end
     end
   end

data/lib/enum_kit/active_record_extensions/schema_dumper.rb

@@ -12,19 +12,25 @@ module EnumKit
       # :nodoc:
       #
       def tables(stream)
-        export_enums(stream)
+        enums(stream)
         super
       end
 
-      # :nodoc:
+      # Write `create_enum` statements for each of the enum types created in the database to the specified stream.
+      #
+      # @param stream [IO] The stream to write the statements into.
       #
-      def export_enums(stream)
-        @connection.enums.each do |name, values|
-          values = values.map(&:inspect).join(', ')
-          stream.puts "  create_enum #{name.inspect}, [#{values}]"
+      def enums(stream)
+        return unless @connection.respond_to?(:enums)
+
+        statements = @connection.enums.map do |name, values|
+          "  create_enum #{name.inspect}, #{values.inspect}"
         end
 
-        stream.puts if @connection.enums.any?
+        return if statements.empty?
+
+        stream.puts statements.join("\n")
+        stream.puts
       end
     end
   end

data/lib/enum_kit/active_record_patches/connection_adapters/postgresql/column_methods.rb

@@ -15,16 +15,16 @@ module ActiveRecord
         # Create an enum column with the provided name.
         #
         # By default, the enum type will match the name of the column.
-        # You can change this behaviour by providing the enum type as an option under the `:name` key.
+        # You can change this behaviour by providing the enum type as an option under the `:enum_type` key.
         #
         # @example Creating a user role.
-        #   t.enum :role, name: :user_role
+        #   t.enum :role, enum_type: :user_role
         #
-        # @param name    [String] The name of the enum column.
-        # @param options [Hash]   The options (including the name of the enum type).
+        # @param enum_type [String] The name of the enum column.
+        # @param options   [Hash]   The options (including the enum type).
         #
         def enum(name, options = {})
-          column(name, options[:name] || name, options.except(:name))
+          column(name, options[:enum_type] || name, options.except(:enum_type))
         end
       end
     end

data/lib/enum_kit/active_record_patches/connection_adapters/postgresql/oid/enum.rb

@@ -15,14 +15,14 @@ module ActiveRecord
         # :nodoc:
         #
         class Enum < Type::Value
-          # @return [String] The PostgreSQL type for the enum.
+          # @return [String] The name of the PostgreSQL type representing the enum.
           #
-          attr_reader :name
+          attr_reader :enum_type
 
           # :nodoc:
           #
           def initialize(options = {})
-            @name = options.delete(:name).to_sym
+            @enum_type = options.delete(:enum_type).to_sym
             super
           end
         end

data/lib/enum_kit/active_record_patches/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -18,7 +18,7 @@ module ActiveRecord
           # :nodoc:
           #
           def register_enum_type(row)
-            register row['oid'], ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum.new(name: row['typname'])
+            register row['oid'], ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum.new(enum_type: row['typname'])
           end
         end
       end

data/lib/enum_kit/active_record_patches/enum.rb

@@ -12,12 +12,11 @@ module ActiveRecord
     # @return [Array]          The acceptable values for the enum type associated with the column.
     #
     def pg_enum_values(name)
-      # Determine the PostgreSQL type name for the enum.
-      type = type_for_attribute(name)
-      type = type.instance_eval { subtype } if type.is_a?(ActiveRecord::Enum::EnumType)
+      # Determine the PostgreSQL type for the enum.
+      type = columns_hash[name.to_s].sql_type
 
       # Query the PostgreSQL database for the enum's acceptable values.
-      connection.enums[type.name]
+      connection.enums[type.to_sym]
     end
 
     # Define a PostgreSQL enum type.
@@ -31,6 +30,9 @@ module ActiveRecord
       enum(name => Hash[values])
 
       enum = type_for_attribute(name)
+
+      raise 'Expected an ActiveRecord::Enum::EnumType' unless enum.is_a?(ActiveRecord::Enum::EnumType)
+
       enum.disable_exceptions = options.key?(:exceptions) && !options[:exceptions]
 
       nil

data/lib/enum_kit/constants.rb

@@ -3,5 +3,5 @@
 module EnumKit
   # @return [String] The gem's semantic version number.
   #
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end

data/spec/active_record/base_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ActiveRecord::Base do
+RSpec.describe ActiveRecord::Base, :unit do
   describe '.pg_enum' do
     it 'is defined' do
       expect(described_class).to respond_to(:pg_enum)

data/spec/active_record/connection_adapters/postgresql_adapter_spec.rb

@@ -1,25 +1,33 @@
 # frozen_string_literal: true
 
-RSpec.describe ActiveRecord::ConnectionAdapters::PostgreSQLAdapter do
+RSpec.describe ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, :unit do
   subject(:connection) { ActiveRecord::Base.connection }
 
-  describe '#create_enum' do
-    after { connection.execute 'DROP TYPE IF EXISTS an_enum' }
+  before do
+    # Sanity check to ensure ActiveRecord is configured to use a PostgreSQL database.
+    expect(connection).to be_a(described_class)
+  end
 
-    it 'is defined' do
-      expect(connection).to respond_to(:create_enum)
+  %i[create_enum rename_enum drop_enum add_enum_value rename_enum_value].each do |method|
+    define_method(method) do |*args, &block|
+      connection.send(method, *args, &block).result_status
     end
+  end
+
+  describe '#create_enum' do
+    after { connection.execute 'DROP TYPE IF EXISTS sizes' }
 
     context 'when called with valid arguments' do
-      subject { connection.create_enum(:an_enum, [:first_value, 'second value']) }
+      subject { create_enum(:sizes, [:small, :medium, :large, 'extra large']) }
 
       it 'creates an enum' do
-        expect(subject.result_status).to eq(PG::PGRES_COMMAND_OK)
+        expect(subject).to eq(PG::PGRES_COMMAND_OK)
+        expect(connection.enums[:sizes]).to eq(['small', 'medium', 'large', 'extra large'])
       end
     end
 
     context 'when called with a malformed name' do
-      subject { connection.create_enum('an enum', [:first_value, 'second value']) }
+      subject { create_enum('bad enum name', [:small, :medium, :large, 'extra large']) }
 
       it 'raises an ArgumentError' do
         expect { subject }.to raise_exception(ArgumentError)
@@ -27,7 +35,7 @@ RSpec.describe ActiveRecord::ConnectionAdapters::PostgreSQLAdapter do
     end
 
     context 'when called with malformed values' do
-      subject { connection.create_enum(:an_enum, [:good_value, 'bad$value']) }
+      subject { create_enum(:sizes, [:small, :medium, :large, 'extra large', 'extra+extra+large']) }
 
       it 'raises an ArgumentError' do
         expect { subject }.to raise_exception(ArgumentError)
@@ -35,24 +43,210 @@ RSpec.describe ActiveRecord::ConnectionAdapters::PostgreSQLAdapter do
     end
   end
 
-  describe '#drop_enum' do
-    before { connection.execute "CREATE TYPE an_enum AS ENUM ('first', 'second')" }
-    after  { connection.execute 'DROP TYPE IF EXISTS an_enum' }
+  describe '#rename_enum' do
+    before do
+      connection.execute "CREATE TYPE sizes AS ENUM ('small', 'medium', 'large', 'extra large')"
+    end
+
+    after do
+      connection.execute 'DROP TYPE IF EXISTS lengths'
+      connection.execute 'DROP TYPE IF EXISTS sizes'
+    end
+
+    context 'when called with valid arguments' do
+      subject { rename_enum(:sizes, :lengths) }
 
-    it 'is defined' do
-      expect(connection).to respond_to(:drop_enum)
+      it 'renames the enum' do
+        expect(subject).to eq(PG::PGRES_COMMAND_OK)
+        expect(connection.enums).to have_key(:lengths)
+        expect(connection.enums).not_to have_key(:sizes)
+      end
     end
 
-    context 'when called with an existing enum' do
-      subject { connection.drop_enum(:an_enum) }
+    context 'when called with a non-existent enum name' do
+      subject { rename_enum(:non_existent_enum, :lengths) }
+
+      it 'raises ActiveRecord::StatementInvalid' do
+        expect { subject }.to raise_exception(ActiveRecord::StatementInvalid)
+      end
+    end
+
+    context 'when called with a malformed current name' do
+      subject { rename_enum('bad enum name', :lengths) }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context 'when called with a malformed new name' do
+      subject { rename_enum(:sizes, 'bad enum name') }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe '#drop_enum' do
+    before { connection.execute "CREATE TYPE sizes AS ENUM ('small', 'medium', 'large', 'extra large')" }
+    after  { connection.execute 'DROP TYPE IF EXISTS sizes' }
+
+    context 'when called with valid arguments' do
+      subject { drop_enum(:sizes) }
 
       it 'drops the enum' do
-        expect(subject.result_status).to eq(PG::PGRES_COMMAND_OK)
+        expect(subject).to eq(PG::PGRES_COMMAND_OK)
+        expect(connection.enums).not_to have_key(:sizes)
+      end
+    end
+
+    context 'when called with a non-existent enum name' do
+      subject { drop_enum(:non_existent_enum) }
+
+      it 'raises ActiveRecord::StatementInvalid' do
+        expect { subject }.to raise_exception(ActiveRecord::StatementInvalid)
+      end
+    end
+
+    context 'when called with a malformed name' do
+      subject { drop_enum('bad enum name') }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe '#add_enum_value' do
+    before { connection.execute "CREATE TYPE sizes AS ENUM ('small', 'large', 'extra large')" }
+    after  { connection.execute 'DROP TYPE IF EXISTS sizes' }
+
+    context 'when called with valid arguments' do
+      subject { add_enum_value(:sizes, 'extra extra large') }
+
+      it 'appends the value' do
+        expect(subject).to eq(PG::PGRES_COMMAND_OK)
+        expect(connection.enums[:sizes]).to eq(['small', 'large', 'extra large', 'extra extra large'])
+      end
+
+      context 'with :before' do
+        subject { add_enum_value(:sizes, 'extra small', before: :small) }
+
+        it 'inserts the value at the correct position' do
+          expect(subject).to eq(PG::PGRES_COMMAND_OK)
+          expect(connection.enums[:sizes]).to eq(['extra small', 'small', 'large', 'extra large'])
+        end
+      end
+
+      context 'with :after' do
+        subject { add_enum_value(:sizes, :medium, after: :small) }
+
+        it 'inserts the value at the correct position' do
+          expect(subject).to eq(PG::PGRES_COMMAND_OK)
+          expect(connection.enums[:sizes]).to eq(['small', 'medium', 'large', 'extra large'])
+        end
+      end
+
+      context 'with :before and :after' do
+        subject { add_enum_value(:sizes, :medium, before: :large, after: :small) }
+
+        it 'raises an ArgumentError' do
+          expect { subject }.to raise_exception(ArgumentError)
+        end
+      end
+    end
+
+    context 'when called with a non-existent enum name' do
+      subject { add_enum_value(:non_existent_enum, :new_value) }
+
+      it 'raises ActiveRecord::StatementInvalid' do
+        expect { subject }.to raise_exception(ActiveRecord::StatementInvalid)
+      end
+    end
+
+    context 'when called with a malformed name' do
+      subject { add_enum_value('bad enum name', :new_value) }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe '#rename_enum_value' do
+    before { connection.execute "CREATE TYPE sizes AS ENUM ('small', 'medium', 'large', 'extra large')" }
+    after  { connection.execute 'DROP TYPE IF EXISTS sizes' }
+
+    context 'when called with valid arguments' do
+      subject { rename_enum_value(:sizes, 'extra large', :extra_large) }
+
+      it 'renames the value' do
+        expect(subject).to eq(PG::PGRES_COMMAND_OK)
+        expect(connection.enums[:sizes]).to eq(%w[small medium large extra_large])
+      end
+
+      context 'when using PostgreSQL < 10.0' do
+        before do
+          allow(connection).to receive(:postgresql_version).and_return(99_999)
+        end
+
+        it 'raises a NotImplementedError' do
+          expect { subject }.to raise_exception(NotImplementedError)
+        end
+      end
+    end
+
+    context 'when called with a non-existent enum name' do
+      subject { rename_enum_value(:non_existent_enum, :previous_value, :new_value) }
+
+      it 'raises ActiveRecord::StatementInvalid' do
+        expect { subject }.to raise_exception(ActiveRecord::StatementInvalid)
+      end
+    end
+
+    context 'when called with a non-existent enum value' do
+      subject { rename_enum_value(:sizes, 'extra extra large', :extra_extra_large) }
+
+      it 'raises ActiveRecord::StatementInvalid' do
+        expect { subject }.to raise_exception(ActiveRecord::StatementInvalid)
+      end
+    end
+
+    context 'when called with a malformed name' do
+      subject { rename_enum_value('bad enum name', 'extra large', :extra_large) }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context 'when called with a malformed current value' do
+      subject { rename_enum_value(:sizes, 'extra-large', :extra_large) }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context 'when called with a malformed new value' do
+      subject { rename_enum_value(:sizes, 'extra large', 'extra-large') }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context 'when called with an equivalent current value and new value' do
+      subject { rename_enum_value(:sizes, 'extra large', 'extra large') }
+
+      it 'raises ActiveRecord::StatementInvalid' do
+        expect { subject }.to raise_exception(ActiveRecord::StatementInvalid)
       end
     end
 
-    context 'when called with a non-existent enum' do
-      subject { connection.drop_enum(:non_existent_enum) }
+    context 'when called with a new value matching an existing value' do
+      subject { rename_enum_value(:sizes, 'extra large', :large) }
 
       it 'raises ActiveRecord::StatementInvalid' do
         expect { subject }.to raise_exception(ActiveRecord::StatementInvalid)

data/spec/active_record/schema_dumper_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveRecord::SchemaDumper, :unit do
+  let(:connection) { ActiveRecord::Base.connection }
+  let(:stream)     { StringIO.new }
+
+  subject do
+    options = {
+      table_name_prefix: ActiveRecord::Base.table_name_prefix,
+      table_name_suffix: ActiveRecord::Base.table_name_suffix
+    }
+
+    described_class.send(:new, connection, options)
+  end
+
+  describe '#enums' do
+    let(:result) do
+      subject.enums(stream)
+      stream.rewind
+      stream.read
+    end
+
+    context 'when the database has enums' do
+      before do
+        expect(connection).to receive(:enums).and_return(color: %w[red green blue], size: %w[small medium large])
+      end
+
+      it 'generates matching `create_enum` statements' do
+        expect(result).to include('create_enum :color, ["red", "green", "blue"]')
+        expect(result).to include('create_enum :size, ["small", "medium", "large"]')
+      end
+    end
+
+    context 'when the database has no enums' do
+      before do
+        expect(connection).to receive(:enums).and_return({})
+      end
+
+      it 'generates nothing' do
+        expect(result).to be_empty
+      end
+    end
+  end
+
+  describe '#tables' do
+    it 'invokes #enums' do
+      expect(subject).to receive(:enums).with(stream).once
+      subject.tables(stream)
+    end
+  end
+end

data/spec/active_record/schema_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ActiveRecord Schema', :integration do
+  let(:connection) { ActiveRecord::Base.connection }
+  let(:stream)     { StringIO.new }
+
+  subject do
+    ActiveRecord::SchemaDumper.dump(connection, stream)
+    stream.rewind
+    stream.read.split("\n").map { |line| line.gsub(/\s+/, ' ').strip }
+  end
+
+  it 'includes `create_enum` statements' do
+    expect(subject).to include('create_enum :shirt_size, ["small", "medium", "large"]')
+  end
+
+  it 'includes `t.enum` statements' do
+    expect(subject).to include('t.enum "size", enum_type: "shirt_size"')
+  end
+end

data/spec/active_record/validations/pg_enum_validator_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe ActiveRecord::Validations::PgEnumValidator do
+RSpec.describe ActiveRecord::Validations::PgEnumValidator, :unit do
   subject { Shirt.create(name: 'Plain Shirt', size: :small) }
 
   it 'permits known values' do

data/spec/internal/db/schema.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 ActiveRecord::Schema.define do
-  create_enum :shirt_size,  %w[small medium large]
+  create_enum :shirt_size, %w[small medium large]
 
   create_table :shirts do |t|
     t.string :name
-    t.enum   :size, name: :shirt_size
+    t.enum   :size, enum_type: :shirt_size
   end
 end

data/spec/spec_helper.rb

@@ -70,11 +70,14 @@ RSpec.configure do |config|
   #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
   config.disable_monkey_patching!
 
-  # Many RSpec users commonly either run the entire suite or an individual file, and it's useful to allow more verbose
-  # output when running an individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output, unless a formatter has already been configured (e.g. via a
-    # command-line flag).
+  # Retrieve the default formatter from the current environment.
+  default_formatter = ENV['RSPEC_DEFAULT_FORMATTER']
+
+  if default_formatter.is_a?(String) && !default_formatter.empty?
+    config.default_formatter = default_formatter
+  elsif config.files_to_run.one?
+    # Use the documentation formatter for detailed output when running an individual spec file, unless a formatter has
+    # already been configured (e.g. via a command-line flag or using the RSPEC_DEFAULT_FORMAT environment variable).
     config.default_formatter = 'doc'
   end
 

data/travis/gemfiles/5.2.gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord',  '~> 5.2.0'
+gem 'activesupport', '~> 5.2.0'

data/travis/gemfiles/6.0.gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord',  '~> 6.0.0'
+gem 'activesupport', '~> 6.0.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Nialto Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 2019-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.2.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 5.2.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +186,8 @@ files:
 - lib/enum_kit/helpers.rb
 - spec/active_record/base_spec.rb
 - spec/active_record/connection_adapters/postgresql_adapter_spec.rb
+- spec/active_record/schema_dumper_spec.rb
+- spec/active_record/schema_spec.rb
 - spec/active_record/validations/pg_enum_validator_spec.rb
 - spec/enum_kit/constants_spec.rb
 - spec/enum_kit/helpers_spec.rb
@@ -194,6 +196,8 @@ files:
 - spec/internal/db/schema.rb
 - spec/internal/log/.gitignore
 - spec/spec_helper.rb
+- travis/gemfiles/5.2.gemfile
+- travis/gemfiles/6.0.gemfile
 homepage: https://github.com/nialtoservices/enum_kit
 licenses:
 - MIT
@@ -221,6 +225,8 @@ summary: Native PostgreSQL enum support for Ruby on Rails.
 test_files:
 - spec/active_record/base_spec.rb
 - spec/active_record/connection_adapters/postgresql_adapter_spec.rb
+- spec/active_record/schema_dumper_spec.rb
+- spec/active_record/schema_spec.rb
 - spec/active_record/validations/pg_enum_validator_spec.rb
 - spec/enum_kit/constants_spec.rb
 - spec/enum_kit/helpers_spec.rb