mv-postgresql 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5312214a363c7e4dd85d54c07bc72f29791d7ba7
-  data.tar.gz: 58a0227278138a421c75bdee96ee1bf72b616b2c
+  metadata.gz: 94eefeb9c7c044f630e3cb2662f623b2c40698e9
+  data.tar.gz: 2f43fd4ed316b6e55f296fbd34245e7a03fe4ac9
 SHA512:
-  metadata.gz: 560d9087028db2e17a187ac876ac9fee9ec467f4cb4df27ec63a3a24c614e690c0907cda91a7445f49e17b04c14ae4173a1d1cc934c7decc7c5886bd9db09ddd
-  data.tar.gz: 8ac04ec6d42cf0492d3c28efbb5301b3fed8e86e02f7fee0131ce60dc0c8450898040b155bb658418fb77cc058edffbb360d462ad06a5f04037f342d3341e3c8
+  metadata.gz: 4e9a36dc51c29c4e46ddaf5e11e497d56a848324f6184ff9cd50a26f0ad2b830b557d599903f32704762e9c439f451910984839983f30799ee733e85106545df
+  data.tar.gz: 31a0708571c79086c918343565e03fb63e484585671996b8ba73799923bbe9104d701e744b092ab9aebec284277a801b046d40870ccf0153bc4aeb8dab73e2a8

data/README.md

@@ -2,11 +2,24 @@
 [![Coverage Status](https://coveralls.io/repos/vprokopchuk256/mv-postgresql/badge.png?branch=master)](https://coveralls.io/r/vprokopchuk256/mv-postgresql?branch=master)
 [![Gem Version](https://badge.fury.io/rb/mv-postgresql.svg)](http://badge.fury.io/rb/mv-postgresql)
 
-# Introduction
+# `Migration Validators` project. PostgreSQL driver. 
 
-mv-postgresql is the PostgreSQL driver for Migration Validators project (details here: https://github.com/vprokopchuk256/mv-core). Allows RoR developer to define database constraints in a familiar ActiveRecord validations manner
+Define validations directly in DB as PostgreSQL constraints and integrate them into your model transparently. See [mv-core](https://github.com/vprokopchuk256/mv-core) for details. There you will be able to review high level project information. Below you can see details of the migration validations that are supported by PostgreSQL driver.  
 
-# Validators
+#Table Of Contents
+* [Validations](#validations)
+  * [uniqueness](#uniqueness)
+  * [length](#length)
+  * [inclusion](#inclusion)
+  * [exclusion](#exclusion)
+  * [presence](#presence)
+  * [absence](#absence)
+  * [format](#format)
+  * [custom](#custom)
+* [Version History](#version history)
+* [Contributing](#contributing)
+
+# Validations
 
 ### uniqueness
 
@@ -15,41 +28,71 @@ mv-postgresql is the PostgreSQL driver for Migration Validators project (details
   validate uniqueness of the column `column_name`:
   
   ```ruby
-  validates :table_name, :column_name, uniqueness: true
+  def up
+    validates :table_name, :column_name, uniqueness: true
+  end
+
+  def down
+    validates :table_name, :column_name, uniqueness: false
+  end
   ```
 
   define validation as trigger with specified failure message:  
 
   ```ruby
-  validates :table_name, :column_name, 
-                  uniqueness: { message: 'Error message', as: :trigger }
+  def up
+    validates :table_name, :column_name, 
+                    uniqueness: { message: 'Error message', as: :trigger }
+  end
+
+  def down
+    validates :table_name, :column_name, uniqueness: false
+  end
   ```
 
   define validation as unique index: 
 
   ```ruby
-  validates :table_name, :column_name, uniqueness: { as: :index }
+  def up
+    validates :table_name, :column_name, uniqueness: { as: :index }
+  end
+
+  def down
+    validates :table_name, :column_name, uniqueness: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-     t.string :column_name, validates: { uniqueness: true }
+  def change
+    create_table :table_name do |t|
+       t.string :column_name, validates: { uniqueness: true }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-     t.change :column_name, :string, validates: { uniqueness: false }
+  def up
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { uniqueness: false }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { uniqueness: false }
+    end
   end
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-     t.string :column_name, uniqueness: true
+  def change
+    create_table :table_name do |t|
+       t.string :column_name, uniqueness: true
+    end
   end
   ```
 
@@ -69,58 +112,94 @@ mv-postgresql is the PostgreSQL driver for Migration Validators project (details
 Examples: 
 
   ```ruby
-  validates :table_name, :column_name, 
-            length: { in: 5..8, message: 'Wrong length message'}
+  def up
+    validates :table_name, :column_name, 
+              length: { in: 5..8, message: 'Wrong length message'}
+  end
+
+  def down
+    validates :table_name, :column_name, length: false
+  end
   ```
 
 allow `NULL`:
 
   ```ruby
-  validates :table_name, :column_name, 
-            length: { is: 3, allow_nil: true}
+  def up
+    validates :table_name, :column_name, 
+              length: { is: 3, allow_nil: true}
+  end
+
+  def down
+    validates :table_name, :column_name, length: false
+  end
   ```
 
   allow blank values: 
 
   ```ruby
-  validates :table_name, :column_name, 
-            length: { maximum: 3, 
-                      allow_blank: true, 
-                      too_long: 'Value is longer than 3 symbols' } 
+  def up
+    validates :table_name, :column_name, 
+              length: { maximum: 3, 
+                        allow_blank: true, 
+                        too_long: 'Value is longer than 3 symbols' } 
+  end
+
+  def down
+    validates :table_name, :column_name, length: false
+  end
   ```
 
   define constraint in trigger: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                        length: { maximum: 3, 
-                                  as: :trigger, 
-                                  too_long: 'Value is longer than 3 symbols' } 
+  def up
+    validates :table_name, :column_name, 
+                         length: { maximum: 3, 
+                                   as: :trigger, 
+                                   too_long: 'Value is longer than 3 symbols' } 
+  end
+
+  def down
+    validates :table_name, :column_name, length: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-     t.string :column_name, validates: { length: { is: 3, allow_nil: true} }
+  def change
+    create_table :table_name do |t|
+       t.string :column_name, validates: { length: { is: 3, allow_nil: true} }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-     t.change :column_name, :string, validates: { length: { is: 3 } }
+  def up
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { length: { is: 3 } }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { length: false }
+    end
   end
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :string_3, length: 3
-    t.string :string_from_1_to_3, length: 1..3,
-    t.string :string_1_or_3, length: [1, 3]
-    t.string :string_4, validates: { length: 4 }
-    t.string :string_4_in_trigger: length: { is: 4, as: :trigger }
+  def change
+    create_table :table_name do |t|
+      t.string :string_3, length: 3
+      t.string :string_from_1_to_3, length: 1..3,
+      t.string :string_1_or_3, length: [1, 3]
+      t.string :string_4, validates: { length: 4 }
+      t.string :string_4_in_trigger: length: { is: 4, as: :trigger }
+    end
   end
   ```
 
@@ -148,55 +227,91 @@ allow `NULL`:
   valid values array: 
 
   ```ruby
-  validates :table_name, :column_name, inclusion: { in: [1, 2, 3] }
+  def up
+    validates :table_name, :column_name, inclusion: { in: [1, 2, 3] }
+  end
+
+  def down
+    validates :table_name, :column_name, inclusion: false
+  end
   ```
 
   with failure message specified: 
 
   ```ruby
-  validates :table_name, :column_name, 
-  inclusion: { in: [1, 2, 3], 
-               message: "Column 'column_name' should be equal to 1 or 2 or 3" }
+  def up
+    validates :table_name, :column_name, 
+    inclusion: { in: [1, 2, 3], 
+                 message: "Column value should be equal to 1 or 2 or 3" }
+  end
+
+  def down
+    validates :table_name, :column_name, inclusion: false
+  end
   ```
 
   make it as check constraint:
 
   ```ruby
-  validates :table_name, :column_name, 
-            inclusion: { in: [1, 2, 3], as: :check }
+  def up
+    validates :table_name, :column_name, 
+              inclusion: { in: [1, 2, 3], as: :check }
+  end
+
+  def down
+    validates :table_name, :column_name, inclusion: false
+  end
   ```
 
   make it in trigger: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                         inclusion: { in: 1..3, 
-                                      on: :create, 
-                                      as: :trigger }
+  def up
+    validates :table_name, :column_name, 
+                           inclusion: { in: 1..3, 
+                                        on: :create, 
+                                        as: :trigger }
+  end
+
+  def down
+    validates :table_name, :column_name, inclusion: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-     t.integer :column_name, validates: { inclusion: { in: 1..3 } }
+  def change
+    create_table :table_name do |t|
+       t.integer :column_name, validates: { inclusion: { in: 1..3 } }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-     t.change :column_name, :integer, validates: { inclusion: { in: 1..3 } }
+  def up
+    change :table_name do |t|
+       t.change :column_name, :integer, validates: { inclusion: { in: 1..3 } }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+       t.change :column_name, :integer, validates: { inclusion: false }
+    end
   end
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :str_or_str_1, inclusion: ['str', 'str1']
-    t.string :from_str_to_str_1, inclusion: 'str'..'str1'
-    t.string :str_or_str_1_in_trigger, inclusion: { in: ['str', 'str1'], 
-                                                    as: :trigger}
+  def change
+    create_table :table_name do |t|
+      t.string :str_or_str_1, inclusion: ['str', 'str1']
+      t.string :from_str_to_str_1, inclusion: 'str'..'str1'
+      t.string :str_or_str_1_in_trigger, inclusion: { in: ['str', 'str1'], 
+                                                      as: :trigger}
+    end
   end
   ```
 
@@ -221,64 +336,102 @@ allow `NULL`:
   within `create_table` statement: 
 
   ```ruby
-  create_tablel :tabld_name do |t|
-    t.integer :column_name, validates: { exclusion: { in: [1, 2, 3] } }
+  def change
+    create_table :tabld_name do |t|
+      t.integer :column_name, validates: { exclusion: { in: [1, 2, 3] } }
+    end
   end
   ```
 
   or as standalone statements: 
 
   ```ruby
-  validates :table_name, :column_name, exclusion: { in: [1, 2, 3] }
+  def up
+    validates :table_name, :column_name, exclusion: { in: [1, 2, 3] }
+  end
+
+  def down
+    validates :table_name, :column_name, exclusion: false
+  end
   ```
 
   the same with failure message: 
 
   ```ruby
-  validates :table_name, :column_name, 
-    exclusion: {
-      in: [1, 2, 3], 
-      message: "Column 'column_name' should not  be equal to 1 or 2 or 3" }
+  def up
+    validates :table_name, :column_name, 
+      exclusion: {
+        in: [1, 2, 3], 
+        message: "Column 'column_name' should not  be equal to 1 or 2 or 3" }
+  end
+
+  def down
+    validates :table_name, :column_name, exclusion: false
+  end
   ```
 
   as check constraint: 
 
   ```ruby
+  def up
   validates :table_name, :column_name, 
                          exclusion: { in: [1, 2, 3], as: :check }
+  end
+
+  def down
+    validates :table_name, :column_name, exclusion: false
+  end
   ```
 
   as trigger: 
 
   ```ruby
+  def up
   validates :table_name, :column_name, 
                                exclusion: { in: 1..3, 
                                             on: :create, 
                                             as: :trigger }
+  end
+
+  def down
+    validates :table_name, :column_name, exclusion: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-     t.integer :column_name, validates: { exclusion: { in: 1..3 } }
+  def change
+    create_table :table_name do |t|
+       t.integer :column_name, validates: { exclusion: { in: 1..3 } }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-     t.change :column_name, :integer, validates: { exclusion: { in: 1..3 } }
+  def up
+    change :table_name do |t|
+       t.change :column_name, :integer, validates: { exclusion: { in: 1..3 } }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+       t.change :column_name, :integer, validates: { exclusion: false }
+    end
   end
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :neither_str_nor_str_1, exclusion: ['str', 'str1']
-    t.string :from_str_to_str_1, exclusion: 'str'..'str1'
-    t.string :str_or_str_1_in_trigger, exclusion: { in: ['str', 'str1'], 
-                                                    as: :trigger}
+  def change
+    create_table :table_name do |t|
+      t.string :neither_str_nor_str_1, exclusion: ['str', 'str1']
+      t.string :from_str_to_str_1, exclusion: 'str'..'str1'
+      t.string :str_or_str_1_in_trigger, exclusion: { in: ['str', 'str1'], 
+                                                      as: :trigger}
+    end
   end
   ```
 
@@ -298,44 +451,78 @@ allow `NULL`:
   Examples: 
 
   ```ruby
-  validates :table_name, :column_name, presence: true
+  def up
+    validates :table_name, :column_name, presence: true
+  end
+
+  def down
+    validates :table_name, :column_name, presence: false
+  end
   ```
 
   with failure message: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                  presence: { message: 'value should not be empty' }
+  def up
+    validates :table_name, :column_name, 
+                    presence: { message: 'value should not be empty' }
+  end
+
+  def down
+    validates :table_name, :column_name, presence: false
+  end
   ```
 
   implemented as trigger: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                  presence: { message: 'value should not be empty', 
-                              as: :trigger }
+  def up
+    validates :table_name, :column_name, 
+                    presence: { message: 'value should not be empty', 
+                                as: :trigger }
+  end
+
+  def down
+    validates :table_name, :column_name, presence: false
+  end
   ```
 
   check when record is inserted only: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                  presence: { message: 'value should not be empty', 
-                              as: :trigger, 
-                              on: :create }
+  def up
+    validates :table_name, :column_name, 
+                    presence: { message: 'value should not be empty', 
+                                as: :trigger, 
+                                on: :create }
+  end
+
+  def down
+    validates :table_name, :column_name, presence: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-     t.string :column_name, validates: { presence: true }
+  def change
+    create_table :table_name do |t|
+       t.string :column_name, validates: { presence: true }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-     t.change :column_name, :string, validates: { presence: true }
+  def up
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { presence: true }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { presence: false }
+    end
   end
   ```
 
@@ -363,53 +550,89 @@ allow `NULL`:
   Examples: 
 
   ```ruby
-  validates :table_name, :column_name, absence: true
+  def up
+    validates :table_name, :column_name, absence: true
+  end
+
+  def down
+    validates :table_name, :column_name, absence: false
+  end
   ```
 
   with failure message: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                  absence: { message: 'value should be empty' }
+  def up
+    validates :table_name, :column_name, 
+                    absence: { message: 'value should be empty' }
+  end
+
+  def down
+    validates :table_name, :column_name, absence: false
+  end
   ```
 
   implemented as trigger: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                  absence: { message: 'value should be empty', 
-                              as: :trigger }
+  def up
+    validates :table_name, :column_name, 
+                    absence: { message: 'value should be empty', 
+                                as: :trigger }
+  end
+
+  def down
+    validates :table_name, :column_name, absence: false
+  end
   ```
 
   check when record is inserted only: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                  absence: { message: 'value should be empty', 
-                              as: :trigger, 
-                              on: :create }
+  def up
+    validates :table_name, :column_name, 
+                    absence: { message: 'value should be empty', 
+                                as: :trigger, 
+                                on: :create }
+  end
+
+  def down
+    validates :table_name, :column_name, absence: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-     t.string :column_name, validates: { absence: true }
+  def change
+    create_table :table_name do |t|
+       t.string :column_name, validates: { absence: true }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-     t.change :column_name, :string, validates: { absence: true }
+  def up
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { absence: true }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+       t.change :column_name, :string, validates: { absence: false }
+    end
   end
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :absence_in_check, absence: true
-    t.string :absence_in_trigger, absence: { as: :trigger, on: :create }
+  def change
+    create_table :table_name do |t|
+      t.string :absence_in_check, absence: true
+      t.string :absence_in_trigger, absence: { as: :trigger, on: :create }
+    end
   end
   ```
 
@@ -430,46 +653,77 @@ allow `NULL`:
   allows only values that contains 'word' inside: 
 
   ```ruby
-  validates :table_name, :column_name, format: { with: /word/ }
+  def up
+    validates :table_name, :column_name, format: { with: /word/ }
+  end
+
+  def down
+    validates :table_name, :column_name, format: false
+  end
   ```
 
   with failure message: 
 
   ```ruby
+  def up
   validates :table_name, :column_name, 
     format: { with: /word/, 
               message: 'Column_name value should contain start word' }
+  end
+
+  def down
+    validates :table_name, :column_name, format: false
+  end
   ```
 
   implemented as trigger:
 
   ```ruby
-  validates :table_name, :column_name, 
-    format: { with: /word/, 
-              message: 'Column_name value should contain start word', 
-              as: :trigger }
+  def up
+    validates :table_name, :column_name, 
+      format: { with: /word/, 
+                message: 'Column_name value should contain start word', 
+                as: :trigger }
+  end
+
+  def down
+    validates :table_name, :column_name, format: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :column_name, validates { format: { with: /word/ } }
+  def change
+    create_table :table_name do |t|
+      t.string :column_name, validates { format: { with: /word/ } }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-    t.change :column_name, :string, validates: { format: { with: /word/ } }
+  def up
+    change :table_name do |t|
+      t.change :column_name, :string, validates: { format: { with: /word/ } }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+      t.change :column_name, :string, validates: { format: false }
+    end
   end
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :contains_word, format: /word/ 
-    t.string :contains_word_in_trigger, format: { with: /word/, as: :trigger }
+  def change
+    create_table :table_name do |t|
+      t.string :contains_word, format: /word/ 
+      t.string :contains_word_in_trigger, format: { with: /word/, 
+                                                    as: :trigger }
+    end
   end
   ```
 
@@ -484,60 +738,92 @@ allow `NULL`:
   * `allow_blank` - ignore validation for blank values. Default value: `false`
   * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`
 
-### custom (version >= 2.1 is required)
+### custom 
+
+  (version >= 2.1 is required)
 
   Examples: 
 
   allows only values that contains 'word' inside: 
 
   ```ruby
-  validates :table_name, :column_name, 
-                         custom: { statement: "TRIM({column_name}) ~ 'word'" }
+  def up
+    validates :table_name, :column_name, 
+                        custom: { statement: "TRIM({column_name}) ~ 'word'" }
+  end
+
+  def down
+    validates :table_name, :column_name, custom: false
+  end
   ```
 
   with failure message: 
 
   ```ruby
-  validates :table_name, :column_name, 
-    custom: { statement: "TRIM({column_name}) ~ 'word'", 
-              message: 'Column_name value should contain start word' }
+  def up
+    validates :table_name, :column_name, 
+      custom: { statement: "TRIM({column_name}) ~ 'word'", 
+                message: 'Column_name value should contain start word' }
+  end
+
+  def down
+    validates :table_name, :column_name, custom: false
+  end
   ```
 
   implemented as trigger:
 
   ```ruby
-  validates :table_name, :column_name, 
-    custom: { statement: "TRIM({column_name}) ~ 'word'", 
-              message: 'Column_name value should contain start word', 
-              as: :trigger }
+  def up
+    validates :table_name, :column_name, 
+      custom: { statement: "TRIM({column_name}) ~ 'word'", 
+                message: 'Column_name value should contain start word', 
+                as: :trigger }
+  end
+
+  def down
+    validates :table_name, :column_name, custom: false
+  end
   ```
 
   all above are available in a create and change table blocks: 
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :column_name, 
+  def change
+    create_table :table_name do |t|
+      t.string :column_name, 
             validates: { custom: { statement: "TRIM({column_name}) ~ 'word'"} }
+    end
   end
   ```
 
   ```ruby
-  change :table_name do |t|
-    t.change :column_name, :string, 
+  def up
+    change :table_name do |t|
+      t.change :column_name, :string, 
             validates: { custom: { statement: "TRIM({column_name}) ~ 'word'"} }
+    end
+  end
+
+  def down
+    change :table_name do |t|
+      t.change :column_name, :string, validates: { custom: false }
+    end
   end
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :contains_word, custom: "TRIM({contains_word}) ~ 'word'"
-    t.string :contains_word_synonym, 
-             validates: "TRIM({contains_word_synonym}) ~ 'word'"
-    t.string :contains_word_in_trigger, 
-             custom: { statement: "TRIM({contains_word_in_trigger}) ~ 'word'", 
-             as: :trigger }
+  def change
+    create_table :table_name do |t|
+      t.string :contains_word, custom: "TRIM({contains_word}) ~ 'word'"
+      t.string :contains_word_synonym, 
+               validates: "TRIM({contains_word_synonym}) ~ 'word'"
+      t.string :contains_word_in_trigger, 
+            custom: { statement: "TRIM({contains_word_in_trigger}) ~ 'word'", 
+            as: :trigger }
+    end
   end
   ```
 
@@ -552,8 +838,22 @@ allow `NULL`:
   * `allow_blank` - ignore validation for blank values. Default value: `false`
   * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger, :check]` Default value: `:check`
 
-## Contributing to mv-postgresql
- 
+## Version History
+
+**(2.0.0)** (17 Jan, 2015)
+
+* Completely rewritten. Migrated to Ruby 2.0 and RoR 4
+
+**(2.1.0)** (22 Jan, 2015)
+
+* Custom validation 
+
+**(2.2.0)** (28 Jan, 2015)
+
+* Integration with ActiveRecord
+
+## Contributing
+
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 * Fork the project
@@ -562,8 +862,3 @@ allow `NULL`:
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
-## Copyright
-
-Copyright (c) 2011 Valeriy Prokopchuk. See LICENSE.txt for
-further details.
-

data/lib/mv-postgresql.rb

@@ -25,6 +25,8 @@ require 'mv/postgresql/validation/builder/trigger/absence'
 require 'mv/postgresql/validation/builder/trigger/uniqueness'
 require 'mv/postgresql/validation/builder/trigger/custom'
 
+require 'mv/postgresql/validation/active_model_presenter/format'
+
 ActiveSupport.on_load(:mv_core) do
   #router
   Mv::Core::Router.define_route(:check, Mv::Postgresql::Route::Check)
@@ -72,5 +74,15 @@ ActiveSupport.on_load(:mv_core) do
     Mv::Postgresql::Validation::Custom   => Mv::Core::Validation::Builder::Custom
   )
 
+  #validation active model presenters
+  Mv::Core::Validation::ActiveModelPresenter::Factory.register_presenters(
+    Mv::Postgresql::Validation::Exclusion   => Mv::Core::Validation::ActiveModelPresenter::Exclusion,
+    Mv::Postgresql::Validation::Inclusion   => Mv::Core::Validation::ActiveModelPresenter::Inclusion,
+    Mv::Postgresql::Validation::Length      => Mv::Core::Validation::ActiveModelPresenter::Length,
+    Mv::Postgresql::Validation::Presence    => Mv::Core::Validation::ActiveModelPresenter::Presence,
+    Mv::Postgresql::Validation::Absence     => Mv::Core::Validation::ActiveModelPresenter::Absence,
+    Mv::Postgresql::Validation::Format      => Mv::Postgresql::Validation::ActiveModelPresenter::Format
+  )
+
 end
 

data/lib/mv/postgresql/validation/active_model_presenter/format.rb

@@ -0,0 +1,17 @@
+module Mv
+  module Postgresql
+    module Validation
+      module ActiveModelPresenter
+        class Format < Mv::Core::Validation::ActiveModelPresenter::Base
+          def option_names
+            super + [:with]
+          end
+
+          def validation_name
+            :format
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mv-postgresql
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Valeriy Prokopchuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
@@ -140,6 +140,7 @@ files:
 - lib/mv/postgresql/railtie.rb
 - lib/mv/postgresql/route/check.rb
 - lib/mv/postgresql/validation/absence.rb
+- lib/mv/postgresql/validation/active_model_presenter/format.rb
 - lib/mv/postgresql/validation/builder/exclusion.rb
 - lib/mv/postgresql/validation/builder/format.rb
 - lib/mv/postgresql/validation/builder/inclusion.rb
@@ -171,7 +172,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='