rein 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a9c78af74657a1a1a30eddab52f82f308dd1a1c
-  data.tar.gz: 72b3d37a29e6d2384ab7c6bc46268544dc560271
+  metadata.gz: a9f1047d5663ba27fedf399e87223e024fe7a6fa
+  data.tar.gz: fe37532d4ee714cd1e1fa281611f4ae61cd5561a
 SHA512:
-  metadata.gz: 2c0229b55c19e5fded597a3f3d0b8836ba073fac83365efcf88fbe0c2a37ab9cde6989d2db7587fd093316742c5aa4692e383c4bb021edc774596a3cc8cf2a2f
-  data.tar.gz: 6bc108d82d305dc4115d7944e4dc84aafc789f92ae2d1349b8ed5273b44e4e07492f75e59bfae3c83ee44d38b7d5b30232bcff695207e652157f865cbb846baf
+  metadata.gz: b3c700dd2bc15a2edf547ac390ec78e4972bc1bb3c7d4f534a495969d4e2e8b014121f9c11a230e415ba892c0e22a16d62bf391f21c69cf5d88bc7eef3d43f02
+  data.tar.gz: 4153810c938897f244d72088e9c0095e99f7f8476c09069f647a4b974d7ad180860d019f6962b3192cf28fa70c2f8a0e549a32f9c6b3cd366d03ca9577bb8d42

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 3.0.0
+
+- Dropped MySQL support.
+- Reversible migrations.
+- Add `index` option to `add_foreign_key_constraint`.
+
 ## 2.1.0
 
 - Add `if` option to inclusion constraints.

data/README.md

@@ -12,6 +12,9 @@ database integrity without resorting to hand-crafted SQL. Rein (pronounced
 "rain") adds a handful of methods to your ActiveRecord migrations so that you
 can easily tame the data in your database.
 
+All methods in the DSL are automatically *reversible*, so you can take
+advantage of reversible Rails migrations.
+
 ## Table of contents
 
 * [Rein](#rein)
@@ -28,14 +31,30 @@ can easily tame the data in your database.
   * [Views](#views)
   * [Schemas](#schemas)
   * [Example](#example)
-  * [Contributing](#contributing)
   * [License](#license)
 
 ## Getting started
 
 Install the gem:
 
-    gem install rein
+```
+> gem install rein
+```
+
+Add a constraint to your migrations:
+
+```ruby
+class CreateAuthorsTable < ActiveRecord::Migration
+  def change
+    create_table :authors do |t|
+      t.string :name, null: false
+    end
+
+    # An author must have a name.
+    add_presence_constraint :authors, :name
+  end
+end
+```
 
 ## Constraint types
 
@@ -51,6 +70,14 @@ For example, let's say that we want to constrain the `author_id` column in the
 add_foreign_key_constraint :books, :authors
 ```
 
+Adding a foreign key doesn't automatically create an index on the referenced
+column. Having an index will generally speed up any joins you perform on the
+foreign key. To create an index you can specify the `index` option:
+
+```ruby
+add_foreign_key_constraint :books, :authors, index: true
+```
+
 Rein will automatically infer the column names for the tables, but if we need
 to be explicit we can using the `referenced` and `referencing` options:
 
@@ -86,8 +113,6 @@ remove_foreign_key_constraint :books, :authors
 
 ### Inclusion constraints
 
-*(PostgreSQL only)*
-
 An inclusion constraint specifies the possible values that a column value can
 take.
 
@@ -123,8 +148,6 @@ add_inclusion_constraint :books, :state,
 
 ### Numericality constraints
 
-*(PostgreSQL only)*
-
 A numericality constraint specifies the range of values that a numeric column
 value can take.
 
@@ -173,8 +196,6 @@ remove_numericality_constraint :books, :publication_month
 
 ### Presence constraints
 
-*(PostgreSQL only)*
-
 A presence constraint ensures that a string column value is non-empty.
 
 A `NOT NULL` constraint will be satisfied by an empty string, but sometimes may
@@ -205,8 +226,6 @@ remove_presence_constraint :books, :title
 
 ### Null constraints
 
-*(PostgreSQL only)*
-
 A null constraint ensures that a column does *not* contain a null value. This
 is the same as adding `NOT NULL` to a column, the difference being that it can
 be _applied conditionally_.
@@ -228,8 +247,6 @@ remove_null_constraint :books, :due_date
 
 ### Enumerated types
 
-*(PostgreSQL only)*
-
 An enum is a data type that represents a static, ordered set of values.
 
 ```ruby
@@ -262,8 +279,6 @@ drop_view :available_books
 
 ## Schemas
 
-*(PostgreSQL only)*
-
 A database can contain one or more named schemas, which in turn contain tables.
 Sometimes it might be helpful to split your database into multiple schemas to
 logically group tables together.

data/lib/rein.rb

@@ -1,41 +1,24 @@
 require "active_record"
-require "active_record/connection_adapters/abstract_mysql_adapter"
-
-require "rein/constraint/options"
-require "rein/constraint/primary_key"
 require "rein/constraint/foreign_key"
 require "rein/constraint/inclusion"
 require "rein/constraint/null"
 require "rein/constraint/numericality"
 require "rein/constraint/presence"
+require "rein/constraint/primary_key"
+require "rein/schema"
 require "rein/type/enum"
 require "rein/view"
-require "rein/schema"
 
 module ActiveRecord
-  module ConnectionAdapters # :nodoc:
-    class MysqlAdapter < AbstractAdapter # :nodoc:
-      include Rein::Constraint::PrimaryKey
-      include Rein::Constraint::ForeignKey
-      include Rein::View
-    end
-
-    class Mysql2Adapter < AbstractMysqlAdapter # :nodoc:
-      include Rein::Constraint::PrimaryKey
-      include Rein::Constraint::ForeignKey
-      include Rein::View
-    end
-
-    class PostgreSQLAdapter < AbstractAdapter # :nodoc:
-      include Rein::Constraint::PrimaryKey
-      include Rein::Constraint::ForeignKey
-      include Rein::Constraint::Inclusion
-      include Rein::Constraint::Null
-      include Rein::Constraint::Numericality
-      include Rein::Constraint::Presence
-      include Rein::Type::Enum
-      include Rein::View
-      include Rein::Schema
-    end
+  class Migration # :nodoc:
+    include Rein::Constraint::ForeignKey
+    include Rein::Constraint::Inclusion
+    include Rein::Constraint::Null
+    include Rein::Constraint::Numericality
+    include Rein::Constraint::Presence
+    include Rein::Constraint::PrimaryKey
+    include Rein::Schema
+    include Rein::Type::Enum
+    include Rein::View
   end
 end

data/lib/rein/constraint/foreign_key.rb

@@ -1,46 +1,46 @@
 require "active_support/inflector"
+require "rein/util"
 
 module Rein
   module Constraint
     # This module contains methods for defining foreign key constraints.
     module ForeignKey
-      def add_foreign_key_constraint(referencing_table, referenced_table, options = {})
-        referencing_attribute = (options[:referencing] || "#{referenced_table.to_s.singularize}_id").to_sym
-        referenced_attribute = (options[:referenced] || "id").to_sym
+      def add_foreign_key_constraint(*args)
+        reversible do |dir|
+          dir.up { _add_foreign_key_constraint(*args) }
+          dir.down { _remove_foreign_key_constraint(*args) }
+        end
+      end
+
+      def remove_foreign_key_constraint(*args)
+        reversible do |dir|
+          dir.up { _remove_foreign_key_constraint(*args) }
+          dir.down { _add_foreign_key_constraint(*args) }
+        end
+      end
 
-        name = options[:name] || default_constraint_name(referencing_table, referencing_attribute)
+      private
 
+      def _add_foreign_key_constraint(referencing_table, referenced_table, options = {})
+        referencing_attribute = (options[:referencing] || "#{referenced_table.to_s.singularize}_id").to_sym
+        referenced_attribute = (options[:referenced] || "id").to_sym
+        name = Util.constraint_name(referencing_table, referencing_attribute, "fk", options)
         sql = "ALTER TABLE #{referencing_table}"
         sql << " ADD CONSTRAINT #{name}"
         sql << " FOREIGN KEY (#{referencing_attribute})"
         sql << " REFERENCES #{referenced_table} (#{referenced_attribute})"
         sql << " ON DELETE #{referential_action(options[:on_delete])}" if options[:on_delete].present?
         sql << " ON UPDATE #{referential_action(options[:on_update])}" if options[:on_update].present?
-
         execute(sql)
-
-        # A foreign key constraint doesn't have an implicit index.
-        add_index(referencing_table, referencing_attribute) if options[:add_index] == true
+        add_index(referencing_table, referencing_attribute) if options[:index] == true
       end
-      alias add_foreign_key add_foreign_key_constraint
 
-      def remove_foreign_key_constraint(referencing_table, referenced_table, options = {})
+      def _remove_foreign_key_constraint(referencing_table, referenced_table, options = {})
         referencing_attribute = options[:referencing] || "#{referenced_table.to_s.singularize}_id".to_sym
-
-        name = options[:name] || default_constraint_name(referencing_table, referencing_attribute)
-
-        if mysql_adapter?
-          execute "ALTER TABLE #{referencing_table} DROP FOREIGN KEY #{name}"
-        else
-          execute "ALTER TABLE #{referencing_table} DROP CONSTRAINT #{name}"
-        end
-
-        # A foreign key constraint doesn't have an implicit index.
-        remove_index(referencing_table, referencing_attribute) if options[:remove_index] == true
+        name = Util.constraint_name(referencing_table, referencing_attribute, "fk", options)
+        execute("ALTER TABLE #{referencing_table} DROP CONSTRAINT #{name}")
+        remove_index(referencing_table, referencing_attribute) if options[:index] == true
       end
-      alias remove_foreign_key remove_foreign_key_constraint
-
-      private
 
       def referential_action(action)
         case action.to_sym
@@ -49,15 +49,10 @@ module Rein
         when :restrict then "RESTRICT"
         when :set_null, :nullify then "SET NULL"
         when :set_default, :default then "SET DEFAULT"
-        else
-          raise "Unknown referential action '#{action}'"
+        else raise "Unknown referential action '#{action}'"
         end
       end
 
-      def mysql_adapter?
-        self.class.to_s =~ /Mysql[2]?Adapter/
-      end
-
       def default_constraint_name(referencing_table, referencing_attribute)
         "#{referencing_table}_#{referencing_attribute}_fk".to_sym
       end

data/lib/rein/constraint/inclusion.rb

@@ -1,21 +1,36 @@
-require "active_record/connection_adapters/abstract/quoting"
+require "rein/util"
 
 module Rein
   module Constraint
     # This module contains methods for defining inclusion constraints.
     module Inclusion
       include ActiveRecord::ConnectionAdapters::Quoting
-      include Rein::Constraint::Options
 
-      def add_inclusion_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
+      def add_inclusion_constraint(*args)
+        reversible do |dir|
+          dir.up { _add_inclusion_constraint(*args) }
+          dir.down { _remove_inclusion_constraint(*args) }
+        end
+      end
+
+      def remove_inclusion_constraint(*args)
+        reversible do |dir|
+          dir.up { _remove_inclusion_constraint(*args) }
+          dir.down { _add_inclusion_constraint(*args) }
+        end
+      end
+
+      private
+
+      def _add_inclusion_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "inclusion", options)
         values = options[:in].map { |value| quote(value) }.join(", ")
-        conditions = conditions_with_if("#{attribute} IN (#{values})", options)
+        conditions = Util.conditions_with_if("#{attribute} IN (#{values})", options)
         execute("ALTER TABLE #{table} ADD CONSTRAINT #{name} CHECK (#{conditions})")
       end
 
-      def remove_inclusion_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
+      def _remove_inclusion_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "inclusion", options)
         execute("ALTER TABLE #{table} DROP CONSTRAINT #{name}")
       end
     end

data/lib/rein/constraint/null.rb

@@ -1,18 +1,35 @@
+require "rein/util"
+
 module Rein
   module Constraint
     # This module contains methods for defining null constraints.
     module Null
       include ActiveRecord::ConnectionAdapters::Quoting
-      include Rein::Constraint::Options
 
-      def add_null_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
-        conditions = conditions_with_if("#{attribute} IS NOT NULL", options)
+      def add_null_constraint(*args)
+        reversible do |dir|
+          dir.up { _add_null_constraint(*args) }
+          dir.down { _remove_null_constraint(*args) }
+        end
+      end
+
+      def remove_null_constraint(*args)
+        reversible do |dir|
+          dir.up { _remove_null_constraint(*args) }
+          dir.down { _add_null_constraint(*args) }
+        end
+      end
+
+      private
+
+      def _add_null_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "null", options)
+        conditions = Util.conditions_with_if("#{attribute} IS NOT NULL", options)
         execute("ALTER TABLE #{table} ADD CONSTRAINT #{name} CHECK (#{conditions})")
       end
 
-      def remove_null_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
+      def _remove_null_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "null", options)
         execute("ALTER TABLE #{table} DROP CONSTRAINT #{name}")
       end
     end

data/lib/rein/constraint/numericality.rb

@@ -1,9 +1,9 @@
+require "rein/util"
+
 module Rein
   module Constraint
     # This module contains methods for defining numericality constraints.
     module Numericality
-      include Rein::Constraint::Options
-
       OPERATORS = {
         greater_than: :>,
         greater_than_or_equal_to: :>=,
@@ -13,21 +13,34 @@ module Rein
         less_than_or_equal_to: :<=
       }.freeze
 
-      def add_numericality_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
+      def add_numericality_constraint(*args)
+        reversible do |dir|
+          dir.up { _add_numericality_constraint(*args) }
+          dir.down { _remove_numericality_constraint(*args) }
+        end
+      end
+
+      def remove_numericality_constraint(*args)
+        reversible do |dir|
+          dir.up { _remove_numericality_constraint(*args) }
+          dir.down { _add_numericality_constraint(*args) }
+        end
+      end
+
+      private
 
+      def _add_numericality_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "numericality", options)
         conditions = OPERATORS.slice(*options.keys).map do |key, operator|
           value = options[key]
           [attribute, operator, value].join(" ")
         end.join(" AND ")
-
-        conditions = conditions_with_if(conditions, options)
-
+        conditions = Util.conditions_with_if(conditions, options)
         execute("ALTER TABLE #{table} ADD CONSTRAINT #{name} CHECK (#{conditions})")
       end
 
-      def remove_numericality_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
+      def _remove_numericality_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "numericality", options)
         execute("ALTER TABLE #{table} DROP CONSTRAINT #{name}")
       end
     end

data/lib/rein/constraint/presence.rb

@@ -1,21 +1,38 @@
+require "rein/util"
+
 module Rein
   module Constraint
     # This module contains methods for defining presence constraints.
     module Presence
       include ActiveRecord::ConnectionAdapters::Quoting
-      include Rein::Constraint::Options
 
-      def add_presence_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
-        conditions = conditions_with_if(
+      def add_presence_constraint(*args)
+        reversible do |dir|
+          dir.up { _add_presence_constraint(*args) }
+          dir.down { _remove_presence_constraint(*args) }
+        end
+      end
+
+      def remove_presence_constraint(*args)
+        reversible do |dir|
+          dir.up { _remove_presence_constraint(*args) }
+          dir.down { _add_presence_constraint(*args) }
+        end
+      end
+
+      private
+
+      def _add_presence_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "presence", options)
+        conditions = Util.conditions_with_if(
           "(#{attribute} IS NOT NULL) AND (#{attribute} !~ '^\\s*$')",
           options
         )
         execute("ALTER TABLE #{table} ADD CONSTRAINT #{name} CHECK (#{conditions})")
       end
 
-      def remove_presence_constraint(table, attribute, options = {})
-        name = constraint_name(table, attribute, options)
+      def _remove_presence_constraint(table, attribute, options = {})
+        name = Util.constraint_name(table, attribute, "presence", options)
         execute("ALTER TABLE #{table} DROP CONSTRAINT #{name}")
       end
     end

data/lib/rein/constraint/primary_key.rb

@@ -2,10 +2,30 @@ module Rein
   module Constraint
     # This module contains methods for defining primary key constraints.
     module PrimaryKey
-      def add_primary_key(table, options = {})
+      def add_primary_key(*args)
+        reversible do |dir|
+          dir.up { _add_primary_key(*args) }
+          dir.down { _remove_primary_key(*args) }
+        end
+      end
+
+      def remove_primary_key(*args)
+        reversible do |dir|
+          dir.up { _remove_primary_key(*args) }
+          dir.down { _add_primary_key(*args) }
+        end
+      end
+
+      private
+
+      def _add_primary_key(table, options = {})
+        attribute = (options[:column] || "id").to_sym
+        execute("ALTER TABLE #{table} ADD PRIMARY KEY (#{attribute})")
+      end
+
+      def _remove_primary_key(table, options = {})
         attribute = (options[:column] || "id").to_sym
-        sql = "ALTER TABLE #{table} ADD PRIMARY KEY (#{attribute})"
-        execute(sql)
+        execute("ALTER TABLE #{table} DROP CONSTRAINT #{attribute}_pkey")
       end
     end
   end

data/lib/rein/schema.rb

@@ -1,14 +1,28 @@
 module Rein
   # This module contains methods for creating/dropping schemas.
   module Schema
-    def create_schema(name)
-      sql = "CREATE SCHEMA #{name}"
-      execute(sql)
+    def create_schema(*args)
+      reversible do |dir|
+        dir.up { _create_schema(*args) }
+        dir.down { _drop_schema(*args) }
+      end
     end
 
-    def drop_schema(name)
-      sql = "DROP SCHEMA #{name}"
-      execute(sql)
+    def drop_schema(*args)
+      reversible do |dir|
+        dir.up { _drop_schema(*args) }
+        dir.down { _create_schema(*args) }
+      end
+    end
+
+    private
+
+    def _create_schema(name)
+      execute("CREATE SCHEMA #{name}")
+    end
+
+    def _drop_schema(name)
+      execute("DROP SCHEMA #{name}")
     end
   end
 end

data/lib/rein/type/enum.rb

@@ -6,18 +6,34 @@ module Rein
     module Enum
       include ActiveRecord::ConnectionAdapters::Quoting
 
-      def create_enum_type(enum_name, enum_values = [])
-        enum_values = enum_values.map { |value| quote(value) }.join(", ")
-        execute("CREATE TYPE #{enum_name} AS ENUM (#{enum_values})")
+      def create_enum_type(*args)
+        reversible do |dir|
+          dir.up { _create_enum_type(*args) }
+          dir.down { _drop_enum_type(*args) }
+        end
       end
 
-      def drop_enum_type(enum_name)
-        execute("DROP TYPE #{enum_name}")
+      def drop_enum_type(*args)
+        reversible do |dir|
+          dir.up { _drop_enum_type(*args) }
+          dir.down { _create_enum_type(*args) }
+        end
       end
 
       def add_enum_value(enum_name, new_value)
         execute("ALTER TYPE #{enum_name} ADD VALUE #{quote(new_value)}")
       end
+
+      private
+
+      def _create_enum_type(enum_name, enum_values = [])
+        enum_values = enum_values.map { |value| quote(value) }.join(", ")
+        execute("CREATE TYPE #{enum_name} AS ENUM (#{enum_values})")
+      end
+
+      def _drop_enum_type(enum_name)
+        execute("DROP TYPE #{enum_name}")
+      end
     end
   end
 end

data/lib/rein/util.rb

@@ -0,0 +1,18 @@
+module Rein
+  module Constraint
+    # The {Util} module provides utility methods for handling options.
+    module Util
+      def self.conditions_with_if(conditions, options = {})
+        if options[:if].present?
+          "NOT (#{options[:if]}) OR (#{conditions})"
+        else
+          conditions
+        end
+      end
+
+      def self.constraint_name(table, attribute, suffix, options = {})
+        options[:name].presence || "#{table}_#{attribute}_#{suffix}"
+      end
+    end
+  end
+end

data/lib/rein/version.rb

@@ -1,3 +1,3 @@
 module Rein
-  VERSION = "2.1.0".freeze
+  VERSION = "3.0.0".freeze
 end

data/lib/rein/view.rb

@@ -1,14 +1,28 @@
 module Rein
   # This module contains methods for creating/dropping views.
   module View
-    def create_view(view_name, sql)
-      sql = "CREATE VIEW #{view_name} AS #{sql}"
-      execute(sql)
+    def create_view(*args)
+      reversible do |dir|
+        dir.up { _create_view(*args) }
+        dir.down { _drop_view(*args) }
+      end
     end
 
-    def drop_view(view_name)
-      sql = "DROP VIEW #{view_name}"
-      execute(sql)
+    def drop_view(*args)
+      reversible do |dir|
+        dir.up { _drop_view(*args) }
+        dir.down { _create_view(*args) }
+      end
+    end
+
+    private
+
+    def _create_view(view_name, sql)
+      execute("CREATE VIEW #{view_name} AS #{sql}")
+    end
+
+    def _drop_view(view_name)
+      execute("DROP VIEW #{view_name}")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rein
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Joshua Bassett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-08 00:00:00.000000000 Z
+date: 2017-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -149,11 +149,11 @@ files:
 - lib/rein/constraint/inclusion.rb
 - lib/rein/constraint/null.rb
 - lib/rein/constraint/numericality.rb
-- lib/rein/constraint/options.rb
 - lib/rein/constraint/presence.rb
 - lib/rein/constraint/primary_key.rb
 - lib/rein/schema.rb
 - lib/rein/type/enum.rb
+- lib/rein/util.rb
 - lib/rein/version.rb
 - lib/rein/view.rb
 homepage: http://github.com/nullobject/rein

data/lib/rein/constraint/options.rb

@@ -1,18 +0,0 @@
-module Rein
-  module Constraint
-    # This module defines methods for handling options command to several constraints.
-    module Options
-      def conditions_with_if(conditions, options = {})
-        if options[:if].present?
-          "NOT (#{options[:if]}) OR (#{conditions})"
-        else
-          conditions
-        end
-      end
-
-      def constraint_name(table, attribute, options = {})
-        options[:name].presence || "#{table}_#{attribute}"
-      end
-    end
-  end
-end