mv-sqlite 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c1d336c78c19529b6d63bfcf9e171317a5bcd3f
-  data.tar.gz: ee3c8e102bfb81520190fa0f122f24623fe45752
+  metadata.gz: 51d4641b55199499595f70d9d11d92a4ffdf87d6
+  data.tar.gz: 3ab3f39cb1f4676583e50319862e15dcf564a806
 SHA512:
-  metadata.gz: cdb0c7946a01247e8218ce9b68fcf4f1fb31ec924e20cbd73a82b4c9832d42b631d9c3d125b85b7ac9117c3b4f246b3d7828cee938c12087b965bca6dd3510c9
-  data.tar.gz: f14e20bcb40b4241121a06ba7e5c6bfda7bb8c1b0d2ab1189c6b72d6a30cf717c594fb3edd0d72c7a9f5f9c999cc697c2812aeae8700ba6c30ff0aaf78bcfd36
+  metadata.gz: 3797e535bfdbb4657be3f10de18e71ed210cfbf552f57a47b6c116942f41a641d4696e2bca5a4d81ca63de670628343b58f89532c13a438a0b5b4119992a6514
+  data.tar.gz: 367eec5f94bf1bf72976e7dfd8d4f99e90f6b2159ec233f1320f71b2b9d501e00f8e3e9ef102bf16ddce1d1748392dcaeff2db8d5cddf6a830e063c8b062a3a2

data/README.md

@@ -2,9 +2,9 @@
 [![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)
 
-# `Migration Validators` project. SQLite driver. 
+# `Migration Validators` project. SQLite driver.
 
-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.  
+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.
 
 #Table Of Contents
 * [Validations](#validations)
@@ -41,7 +41,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
+    validates :table_name, :column_name,
               uniqueness: { message: 'Error message', as: :trigger }
   end
 
@@ -50,7 +50,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  define validation as unique index: 
+  define validation as unique index:
 
   ```ruby
   def up
@@ -62,7 +62,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  all above are available in a create and change table blocks: 
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
@@ -96,7 +96,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  Options: 
+  Options:
 
   * `message` - text of the error message that will be shown if constraint violated.  Ignored unless `:as == :trigger`
   * `index_name` - name of the index that will be created for validator. Ignored unless `:as == :index`
@@ -109,14 +109,14 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
 ### length
 
-  Examples: 
+  Examples:
 
-  column value length should be more than 4 symbols and less than 9. Otherwise 'Wrong length message' error will be raised: 
+  column value length should be more than 4 symbols and less than 9. Otherwise 'Wrong length message' error will be raised:
 
- ```ruby 
+ ```ruby
   def up
-    validates :table_name, :column_name, 
-                           length: { in: 5..8, 
+    validates :table_name, :column_name,
+                           length: { in: 5..8,
                                      message: 'Wrong length message' }
   end
 
@@ -129,7 +129,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
+    validates :table_name, :column_name,
                            length: { is: 3, allow_nil: true}
   end
 
@@ -138,21 +138,21 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  allow blank values: 
+  allow blank values:
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
-                         length: { maximum: 3, 
-                                   too_long: 'Value is longer than 3 symbols' } 
+    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: 
+
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
@@ -200,7 +200,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   * `:message` - message that should be shown if validation failed and specific message is not defined
   * `:too_long` - message that will be shown if value longer than allowed. Ignored unless maximum value is defined
   * `:too_short` - message that will be shown if value shorter than allowed. Ignored unless minimum value is defined
-  * `:on` -  validation event. Possible values: `[:save, :update, :create]`. Default value: `:save` 
+  * `: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`
@@ -209,9 +209,9 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
 ### inclusion
 
-  Examples: 
+  Examples:
 
-  valid values array: 
+  valid values array:
 
   ```ruby
   def up
@@ -223,12 +223,12 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  with failure message specified: 
+  with failure message specified:
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
-    inclusion: { in: [1, 2, 3], 
+    validates :table_name, :column_name,
+    inclusion: { in: [1, 2, 3],
                  message: "Column value should be equal to 1 or 2 or 3" }
   end
 
@@ -237,7 +237,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  all above are available in a create and change table blocks: 
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
@@ -268,7 +268,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
     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'], 
+      t.string :str_or_str_1_in_trigger, inclusion: { in: ['str', 'str1'],
                                                       as: :trigger}
     end
   end
@@ -279,18 +279,18 @@ Define validations directly in DB as SQLite constraints and integrate them into
   * `in` - range or array that column value should be contained in.
   * `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 
+  * `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]`
 
-  
+
 ### exclusion
 
   Examples:
 
-  exclude 1, 2, and 3: 
+  exclude 1, 2, and 3:
 
   ```ruby
   def up
@@ -302,13 +302,13 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  the same with failure message: 
+  the same with failure message:
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
+    validates :table_name, :column_name,
       exclusion: {
-        in: [1, 2, 3], 
+        in: [1, 2, 3],
         message: "Column 'column_name' should not  be equal to 1 or 2 or 3" }
   end
 
@@ -317,7 +317,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  all above are available in a create and change table blocks: 
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
@@ -348,7 +348,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
     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'], 
+      t.string :str_or_str_1_in_trigger, exclusion: { in: ['str', 'str1'],
                                                       as: :trigger}
     end
   end
@@ -367,7 +367,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
 ### presence
 
-  Examples: 
+  Examples:
 
   ```ruby
   def up
@@ -379,11 +379,11 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  with failure message: 
+  with failure message:
 
   ```ruby
-  def up  
-    validates :table_name, :column_name, 
+  def up
+    validates :table_name, :column_name,
                     presence: { message: 'value should not be empty' }
   end
 
@@ -392,13 +392,13 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  check when record is inserted only: 
+  check when record is inserted only:
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
-                    presence: { message: 'value should not be empty', 
-                                as: :trigger, 
+    validates :table_name, :column_name,
+                    presence: { message: 'value should not be empty',
+                                as: :trigger,
                                 on: :create }
   end
 
@@ -407,7 +407,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  all above are available in a create and change table blocks: 
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
@@ -454,7 +454,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
 ### absence
 
-  Examples: 
+  Examples:
 
   ```ruby
   def up
@@ -466,11 +466,11 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  with failure message: 
+  with failure message:
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
+    validates :table_name, :column_name,
                     absence: { message: 'value should be empty' }
   end
 
@@ -479,13 +479,13 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  check when record is inserted only: 
+  check when record is inserted only:
 
   ```ruby
-  def up 
-    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,
                                 on: :create }
   end
 
@@ -494,7 +494,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  all above are available in a create and change table blocks: 
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
@@ -539,13 +539,13 @@ Define validations directly in DB as SQLite constraints and integrate them into
   * `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`
 
-### format 
+### format
 
   **WARNING** ```SQLite``` does NOT have default ```REGEXP``` implementation. ```mv-sqlite``` contains own implementation that is available with active record connection only. In other words everything should be ok if you access database from withing rails console or rails application or other application that uses ```activerecord``` internally. But not defined function error will be thrown when you access database direclty. You can build ```SQLite``` ```ICU``` extension to enable native ```SQLite``` ```REGEXP```. See details here: http://www.sqlite.org/src/artifact?ci=trunk&filename=ext/icu/README.txt.
 
-  Examples: 
+  Examples:
 
-  allows only values that contains 'word' inside: 
+  allows only values that contains 'word' inside:
 
   ```ruby
   def up
@@ -557,12 +557,12 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  with failure message: 
+  with failure message:
 
   ```ruby
   def up
-  validates :table_name, :column_name, 
-    format: { with: /word/, 
+  validates :table_name, :column_name,
+    format: { with: /word/,
               message: 'Column_name value should contain start word' }
   end
 
@@ -575,9 +575,9 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
-      format: { with: /word/, 
-                message: 'Column_name value should contain start word', 
+    validates :table_name, :column_name,
+      format: { with: /word/,
+                message: 'Column_name value should contain start word',
                 as: :trigger }
   end
 
@@ -586,7 +586,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  all above are available in a create and change table blocks: 
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
@@ -615,8 +615,8 @@ Define validations directly in DB as SQLite constraints and integrate them into
   ```ruby
   def change
     create_table :table_name do |t|
-      t.string :contains_word, format: /word/ 
-      t.string :contains_word_in_trigger, format: { with: /word/, 
+      t.string :contains_word, format: /word/
+      t.string :contains_word_in_trigger, format: { with: /word/,
                                                     as: :trigger }
     end
   end
@@ -633,17 +633,17 @@ Define validations directly in DB as SQLite constraints and integrate them into
   * `allow_blank` - ignore validation for blank values. Default value: `false`
   * `as` - defines the way how constraint will be implemented. Possible values: `[:trigger]` Default value: `:trigger`
 
-### custom 
+### custom
 
   (version >= 2.1 is required)
 
-  Examples: 
+  Examples:
 
-  allows only values that equals 'word' when trimmed: 
+  allows only values that equals 'word' when trimmed:
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
+    validates :table_name, :column_name,
                          custom: { statement: "TRIM({column_name}) = 'word'" }
   end
 
@@ -652,12 +652,12 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  with failure message: 
+  with failure message:
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
-      custom: { statement: "TRIM({column_name}) = 'word'", 
+    validates :table_name, :column_name,
+      custom: { statement: "TRIM({column_name}) = 'word'",
                 message: 'Column_name value should contain start word' }
   end
 
@@ -670,10 +670,10 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
   ```ruby
   def up
-    validates :table_name, :column_name, 
-      custom: { statement: "TRIM({column_name}) = 'word'", 
-                message: 'Column_name value should contain start word', 
-                as: :trigger, 
+    validates :table_name, :column_name,
+      custom: { statement: "TRIM({column_name}) = 'word'",
+                message: 'Column_name value should contain start word',
+                as: :trigger,
                 on: :create }
   end
 
@@ -682,12 +682,12 @@ Define validations directly in DB as SQLite constraints and integrate them into
   end
   ```
 
-  all above are available in a create and change table blocks: 
+  all above are available in a create and change table blocks:
 
   ```ruby
   def change
     create_table :table_name do |t|
-      t.string :column_name, 
+      t.string :column_name,
             validates: { custom: { statement: "TRIM({column_name}) = 'word'"} }
     end
   end
@@ -696,7 +696,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   ```ruby
   def up
     change :table_name do |t|
-      t.change :column_name, :string, 
+      t.change :column_name, :string,
             validates: { custom: { statement: "TRIM({column_name}) = 'word'"} }
     end
   end
@@ -714,14 +714,14 @@ Define validations directly in DB as SQLite constraints and integrate them into
   def change
     create_table :table_name do |t|
       t.string :contains_word, custom: "TRIM({contains_word}) = 'word'"
-      t.string :contains_word_synonym, 
+      t.string :contains_word_synonym,
                validates: "TRIM({contains_word_synonym}) = 'word'"
-      t.string :contains_word_in_trigger, 
+      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
@@ -731,7 +731,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
   * `: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)
@@ -740,7 +740,7 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
 **(2.1.0)** (22 Jan, 2015)
 
-* Custom validation 
+* Custom validation
 
 **(2.2.0)** (28 Jan, 2015)
 
@@ -750,6 +750,14 @@ Define validations directly in DB as SQLite constraints and integrate them into
 
 * Made it possible to use several mv-* drivers in the same project
 
+**(2.2.2)** (1 June, 2015)
+
+* Format validation
+
+**(2.2.3)** (20 Jul, 2015)
+
+* Fix issue with invalid parameters number in `add_column` and `change_column` methods
+
 ## Contributing
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mv-sqlite
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Valeriy Prokopchuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-01 00:00:00.000000000 Z
+date: 2015-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: 2.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: 2.2.1
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement