mv-sqlite 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 041135708ece1d93dd74c9f9d6ab910a36113a24
-  data.tar.gz: 0c1ccb017f85ed3b76cfc35d3f523a06c991f375
+  metadata.gz: 7d7c3516a357006e5885434ecd2295a0cd1d795f
+  data.tar.gz: 710018cae984e45c333825a08aeb9fc5fb9d2bd5
 SHA512:
-  metadata.gz: b77f5f0d7851d9e524ef85b8134bac98bec4c9b6ed6a5d7b1276ce2f3ecaa450a757c7fcc78e93a89eae6307faae4ec9e101d8c8fdcfb1cbe50d47764a762205
-  data.tar.gz: 66235c8f42816eff1c18d2fea5451a453f9ab665d37c44c73ae8c1a34b73b0ad5da269c95eb89d34ec92f90c0491db8b35f2d317fba3cb22cb45d0f24cbb59d8
+  metadata.gz: ef9f6cf9fd3880c44f6d483a1e2582e16cbc22d5a07c87779655e02beda8e4596740880e24f06e779599e46703758c12d3a284edf7be0868ed1cd5462e2633ea
+  data.tar.gz: ddad7dd1b74762e5e93285db43094d2b7d7c73d2d609fc36e046e0c093bf6d192b6bf2c271bb5bf239eb999a8e87069cef82d80b4e25dd0a9f66dbdf2d4fa314

data/README.md

@@ -2,11 +2,23 @@
 [![Coverage Status](https://coveralls.io/repos/vprokopchuk256/mv-sqlite/badge.png?branch=master)](https://coveralls.io/r/vprokopchuk256/mv-sqlite?branch=master)
 [![Gem Version](https://badge.fury.io/rb/mv-sqlite.svg)](http://badge.fury.io/rb/mv-sqlite)
 
-# Introduction
+# `Migration Validators` project. SQLite driver. 
 
-mv-sqlite is the SQLite 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 SQLite 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 SQLite driver.  
 
-# Validators
+#Table Of Contents
+* [Validations](#validations)
+  * [uniqueness](#uniqueness)
+  * [length](#length)
+  * [inclusion](#inclusion)
+  * [exclusion](#exclusion)
+  * [presence](#presence)
+  * [absence](#absence)
+  * [custom](#custom)
+* [Version History](#version history)
+* [Contributing](#contributing)
+
+# Validations
 
 ### uniqueness
 
@@ -15,41 +27,71 @@ mv-sqlite is the SQLite driver for Migration Validators project (details here: h
   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: true }
+    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
   ```
 
@@ -71,49 +113,79 @@ mv-sqlite is the SQLite driver for Migration Validators project (details here: h
   column value length should be more than 4 symbols and less than 9. Otherwise 'Wrong length message' error will be raised: 
 
  ```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, 
-                                  too_long: 'Value is longer than 3 symbols' } 
+  def up
+    validates :table_name, :column_name, 
+                         length: { maximum: 3, 
+                                   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
   ```
 
@@ -141,39 +213,63 @@ mv-sqlite is the SQLite driver for Migration Validators project (details here: h
   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
   ```
 
   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
   ```
 
@@ -196,40 +292,64 @@ mv-sqlite is the SQLite driver for Migration Validators project (details here: h
   exclude 1, 2, and 3: 
 
   ```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
   ```
 
   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
   ```
 
@@ -249,45 +369,75 @@ mv-sqlite is the SQLite driver for Migration Validators project (details here: h
   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
   ```
 
   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
   ```
 
   simplifications (version >= 2.1 is required):
 
   ```ruby
-  create_table :table_name do |t|
-    t.string :presence_in_check, presence: true
-    t.string :presence_in_trigger, presence: { as: :trigger, on: :create }
+  def change
+    create_table :table_name do |t|
+      t.string :presence_in_check, presence: true
+      t.string :presence_in_trigger, presence: { as: :trigger, on: :create }
+    end
   end
   ```
 
@@ -306,117 +456,203 @@ mv-sqlite is the SQLite driver for Migration Validators project (details here: h
   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
   ```
 
   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
   ```
 
-### custom (version >= 2.1 is required)
+  Options:
+
+  * `message` - message that should be shown if validation failed
+  * `on` -  validation event. Possible values `[:save, :update, :create]`. Ignored unless `:as == :trigger`. Default value: `:save`
+  * `create_tigger_name` - Name of the 'before insert' trigger that will be created if `:as == :trigger` && `:on` in `[:save, :create]`
+  * `update_tigger_name` - Name of the 'before update' trigger that will be created if `:as == :trigger` && `:on` in `[:save, :update]`
+  * `allow_nil` - ignore validation for `nil` values. Default value: `true`
+  * `allow_blank` - ignore validation for blank values. Default value: `true`
+  * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger]` Default value: `:trigger`
+
+### custom 
+
+  (version >= 2.1 is required)
 
   Examples: 
 
   allows only values that equals 'word' when trimmed: 
 
   ```ruby
-  validates :table_name, :column_name, 
+  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 on insert event:
 
   ```ruby
-  validates :table_name, :column_name, 
-    custom: { statement: "TRIM({column_name}) = 'word'", 
-              message: 'Column_name value should contain start word', 
-              as: :trigger, 
-              on: :create }
+  def up
+    validates :table_name, :column_name, 
+      custom: { statement: "TRIM({column_name}) = 'word'", 
+                message: 'Column_name value should contain start word', 
+                as: :trigger, 
+                on: :create }
+  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
   ```
   
   Options:
 
   * `:message` - message that should be shown if validation failed
-  * `:on` -  validation event. Possible values: `[:save, :update, :create]`. Default value: `:save`
-  * `:create_tigger_name` - Name of the 'before insert' trigger
-  * `:update_tigger_name` - Name of the 'before update' trigger
-  * `:allow_nil` - ignore validation for `nil` values. Default value: `false`
+  `:on`  validation event. Possible values `[:save, :update, :create]`. Default value: `:save`
+  * `:create_tigger_name` - name of the 'before insert' trigger
+  * `:update_tigger_name` - name of the 'before update' trigger
+  * `:allow_nil` - ignore validation for nil values. Default value: false
   * `:allow_blank` - ignore validation for blank values. Default value: `false`
   * `:as` - defines the way how constraint will be implemented. Possible values: `[:trigger]`
+  
+## 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
 
-## Contributing to mv-sqlite
- 
 * 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
@@ -425,9 +661,4 @@ mv-sqlite is the SQLite driver for Migration Validators project (details here: h
 * 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) 2015 Valeriy Prokopchuk. See LICENSE.txt for
-further details.
-
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mv-sqlite
 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
@@ -143,7 +143,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:
   - - '>='