flash_validators 1.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62a1fe02cdb774704575c71fd9e94dd70eb4ac61
-  data.tar.gz: 77c9c4f93e1b1010e1e989d8b639a4a77d0a1602
+  metadata.gz: 4150ee9e67b137e4e05e7087f63bbd6b5957fe17
+  data.tar.gz: bf4b5c433dbee35418a093e7727ce88d441880e5
 SHA512:
-  metadata.gz: 159e1bff68ddcec3ea18ba7dad44d6b0cf4b1a66e49ccb99aa7a0df57bc7642e508ba4a32578ddc491f75d470981eb4bb3a875fe8b77ec7767ee611ebc17247b
-  data.tar.gz: e890f7b6401d9f551c2f3b1ee7c24183c9c4d064e54679bffd41366f8c98acb6616d2374b1dcdd93878f7338af1d5d4c82eae9751f9522baf6840ae8daaf44c0
+  metadata.gz: 2d9d77e2859702d00a11cf7c8f94aee316a87a55a87bb0159722f27a900db06068a20a6787b7efccdf20a934b88dc6dea52ff5193a7dd60d3d9c2f13e55c51be
+  data.tar.gz: d9951b4694622675d29881b428b06e74996f5d3b919ab0a8b2cef5c8c49bbc039c6dc911f58969cff1c66e5e75a40f12e24ac60dde34a73a4aee2a4906599252

data/README.md

@@ -7,7 +7,7 @@
 
 Flash Validators is a collection of custom validators that are often required in Rails applications plus shoulda-style RSpec matchers to test the validation rules.
 
-Currently supported validators: alpha, alpha-numeric, boolean, credit card, currency, email, equality, hex, IMEI, IP, ISBN, latitude, longitude, mac address, name, password, phone, slug, ssn, url, and username.
+Currently supported validators: alpha, alpha-numeric, Base64, boolean, credit card, currency, CUSIP, email, equality, GTIN, hex, IMEI, IP, ISBN, ISIN, latitude, longitude, MAC address, name, password, phone, SEDOL, slug, SSN, url, username, and UUID.
 
 Highly recommended validators:
   * **DateTime:** Validates Timeliness - https://github.com/adzap/validates_timeliness
@@ -58,18 +58,18 @@ class Book
 end
 ```
 
-Options: :strict, :lowercase, :uppercase
+Options: :strict, case: [:lower, :upper]
 
 ```ruby
 validates :title, alpha: { strict: true }
-validates :title, alpha: { lowercase: true }
-validates :title, alpha: { uppsercase: true }
+validates :title, alpha: { case: :lower }
+validates :title, alpha: { case: :upper, strict: true }
 ```
 
 RSpec matcher is also available for your convenience:
 
 ```ruby
-describe Product do
+describe Book do
   it { should ensure_valid_alpha_format_of(:title) }
   it { should_not ensure_valid_alpha_format_of(:name) }
 end
@@ -102,6 +102,7 @@ class Book
 end
 ```
 
+Options: :strict
 Strict: requires not including spaces
 
 ```ruby
@@ -111,18 +112,54 @@ validates :title, alpha_numeric: { strict: true }
 RSpec matcher is also available for your convenience:
 
 ```ruby
-describe Product do
+describe Book do
   it { should ensure_valid_alpha_numeric_format_of(:title) }
   it { should_not ensure_valid_alpha_numeric_format_of(:name) }
 end
 ```
 
+### Base64Validator
+
+**Ex:** YW55IGNhcm5hbCBwbGVhcw==
+
+**Rules:**
+ * Characters: 0-1 A-Z =
+
+With an ActiveRecord model:
+
+```ruby
+class Code < ActiveRecord::Base
+  attr_accessor :code, :name
+  validates :code, base64: true
+end
+```
+
+Or any ruby class:
+
+```ruby
+class Code
+  include ActiveModel::Validations
+  attr_accessor :code, :name
+  validates :code, base64: true
+end
+```
+
+RSpec matcher is also available for your convenience:
+
+```ruby
+describe Code do
+  it { should ensure_valid_base64_format_of(:code) }
+  it { should_not ensure_valid_base64_format_of(:name) }
+end
+```
+
 ### BooleanValidator
 
 **Ex:** true or false or 1 or 0
 
 **Rules:**
- * Characters: 0-1 true or false
+ * Characters: 0-1
+ * Equality: true or false
 
 With an ActiveRecord model:
 
@@ -146,19 +183,20 @@ end
 RSpec matcher is also available for your convenience:
 
 ```ruby
-describe Product do
+describe User do
   it { should ensure_valid_boolean_format_of(:active) }
   it { should_not ensure_valid_boolean_format_of(:name) }
 end
 ```
+
 ### CreditCardValidator
 
 **Ex:** 370000000000002
 
 **Rules:**
- * Characters: 0-9
+ * Characters: 0-9 .-
  * Must include: 0-9
- * Range for card digits: 15-16
+ * Range for card digits: 12-19
 
 With an ActiveRecord model:
 
@@ -179,15 +217,13 @@ class Invoice
 end
 ```
 
-Options: :american_express, :diners_club, :discover, :jbc, :master_card, :visa
+Options: :strict, card: [:american_express (:amex), :diners_club, :discover, :jbc, :laser, :maestro, :mastercard, :solo, :unionpay, :visa]
+Strict: requires not including spaces
 
 ```ruby
-validates :cc_number, currency: { american_express: true }
-validates :cc_number, currency: { diners_club: true }
-validates :cc_number, currency: { discover: true }
-validates :cc_number, currency: { jbc: true }
-validates :cc_number, currency: { master_card: true }
-validates :cc_number, currency: { visa: true }
+validates :cc_number, credit_card: { card: :visa }
+validates :cc_number, credit_card: { strict: true }
+validates :cc_number, credit_card: { card: :discover, strict: true }
 ```
 
 RSpec matcher is also available for your convenience:
@@ -227,6 +263,7 @@ class Product
 end
 ```
 
+Options: :strict
 Strict: requires leading number and exactly two decimals, 1.45
 
 ```ruby
@@ -242,6 +279,42 @@ describe Product do
 end
 ```
 
+### CusipValidator
+
+**Ex:** 125509BG3
+
+**Rules:**
+ * Characters: 0-1 A-Z
+ * Length: 1-9
+
+With an ActiveRecord model:
+
+```ruby
+class Bank < ActiveRecord::Base
+  attr_accessor :code, :name
+  validates :code, cusip: true
+end
+```
+
+Or any ruby class:
+
+```ruby
+class Bank
+  include ActiveModel::Validations
+  attr_accessor :code, :name
+  validates :code, cusip: true
+end
+```
+
+RSpec matcher is also available for your convenience:
+
+```ruby
+describe Bank do
+  it { should ensure_valid_cusip_format_of(:code) }
+  it { should_not ensure_cusip_base64_format_of(:name) }
+end
+```
+
 ### EmailValidator
 
 **Ex:** user@example.com or user+123@example-site.com
@@ -271,7 +344,7 @@ class User
 end
 ```
 
-You can specify domains to which the email domain should belong in one of the folowing ways:
+Options: :domains
 
 ```ruby
 validates :email, email: { domains: 'com' }
@@ -330,14 +403,59 @@ describe Auction do
 end
 ```
 
+### GtinValidator
+
+**Ex:** 73513537 or 4 006381 33393 1
+
+**Rules:**
+* Length: 8, 12, 13, or 14
+* Characters: 0-9
+
+With an ActiveRecord model:
+
+```ruby
+class Trade < ActiveRecord::Base
+  attr_accessor :code, :name
+  validates :code, gtin: true
+end
+```
+
+Or any ruby class:
+
+```ruby
+class Trade
+  include ActiveModel::Validations
+  attr_accessor :code, :name
+  validates :code, gtin: true
+end
+```
+
+Options: :strict, format: [:ean_8, :gtin_8, :ucc_8, :gtin_12, :upc, :upc_a, :ean, :ean_13, :gtin_13, :ucc_13, :gtin_14, :ucc_14]
+Strict: requires not including spaces
+
+```ruby
+validates :code, gtin: { format: :ean_8 }
+validates :code, gtin: { strict: true }
+validates :code, gtin: { format: :ucc_13, strict: true }
+```
+
+RSpec matcher is also available for your convenience:
+
+```ruby
+describe Trade do
+  it { should ensure_valid_gtin_format_of(:code) }
+  it { should_not ensure_valid_gtin_format_of(:name) }
+end
+```
+
 ### HexValidator
 
-**Ex:** #a9a9a9 or #999 or aaaaaa
+**Ex:** #a9a9a9 or #999 or aaaaaa or AAA
 
 **Rules:**
 * Prefix (non-mandatory): #
 * Length: 3 or 6
-* Characters: a-f 0-9
+* Characters: A-F a-f 0-9
 
 With an ActiveRecord model:
 
@@ -475,6 +593,43 @@ describe User do
 end
 ```
 
+### IsinValidator
+
+**Ex:** US0378331005 or AU0000XVGZA3
+
+**Rules:**
+* Length: 12
+* Characters: 0-9 A-Z
+* Start: valid country code
+
+With an ActiveRecord model:
+
+```ruby
+class Trade < ActiveRecord::Base
+  attr_accessor :isin, :name
+  validates :isin, isin: true
+end
+```
+
+Or any ruby class:
+
+```ruby
+class User
+  include ActiveModel::Validations
+  attr_accessor :isin, :name
+  validates :isin, isin: true
+end
+```
+
+RSpec matcher is also available for your convenience:
+
+```ruby
+describe User do
+  it { should ensure_valid_isin_format_of(:isin) }
+  it { should_not ensure_valid_isin_format_of(:name) }
+end
+```
+
 ### LatitudeValidator
 
 **Ex:** 78.213 or -34.985
@@ -651,7 +806,7 @@ class User
   validates :password, password: true
 end
 ```
-
+Options: :strict
 Strict: requires length between 6 and 18, one number, lowercase, upcase letter
 
 ```ruby
@@ -702,6 +857,41 @@ describe User do
 end
 ```
 
+### SedolValidator
+
+**Ex:** B0WNLY7
+
+**Rules:**
+* Characters: A-Z 0-9
+
+With an ActiveRecord model:
+
+```ruby
+class Trade < ActiveRecord::Base
+  attr_accessor :sedol, :name
+  validates :sedol, sedol: true
+end
+```
+
+Or any ruby class:
+
+```ruby
+class Trade
+  include ActiveModel::Validations
+  attr_accessor :sedol, :name
+  validates :sedol, sedol: true
+end
+```
+
+RSpec matcher is also available for your convenience:
+
+```ruby
+describe Trade do
+  it { should ensure_valid_sedol_format_of(:sedol) }
+  it { should_not ensure_valid_sedol_format_of(:name) }
+end
+```
+
 ### SlugValidator
 
 **Ex:** slug1234 or slug-1234
@@ -800,27 +990,19 @@ class User
 end
 ```
 
-You can specify domains to which the URL domain should belong in one of the folowing ways:
+Options: :domains, :root, :scheme
 
 ```ruby
+validates :url, url: { scheme: :http }
+validates :url, url: { scheme: [:http, 'https'] }
+validates :url, url: { scheme: :http, root: true, domains: :com }
+validates :url, url: { root: true }
+validates :url, url: { root: true, domains: :com }
 validates :url, url: { domains: 'com' }
 validates :url, url: { domains: :com }
 validates :url, url: { domains: [:com, 'edu'] }
 ```
 
-You can specify if the URL should the site root:
-
-```ruby
-validates :url, url: { root: true }
-```
-
-You can specify the URL scheme:
-
-```ruby
-validates :url, url: { scheme: :http }
-validates :url, url: { scheme: [:http, 'https'] }
-```
-
 RSpec matcher is also available for your convenience:
 
 ```ruby
@@ -866,6 +1048,47 @@ describe User do
 end
 ```
 
+### UuidValidator
+
+**Ex:** 886313e1-3b8a-5372-9b90-0c9aee199e5d
+
+**Rules:**
+* Characters: A-Z a-z 0-9 -
+
+With an ActiveRecord model:
+
+```ruby
+class User < ActiveRecord::Base
+  attr_accessor :uuid, :name
+  validates :uuid, uuid: true
+end
+```
+
+Or any ruby class:
+
+```ruby
+class User
+  include ActiveModel::Validations
+  attr_accessor :uuid, :name
+  validates :uuid, username: true
+end
+```
+
+Options: :version
+
+```ruby
+validates :uuid, uuid: { version: 3 }
+```
+
+RSpec matcher is also available for your convenience:
+
+```ruby
+describe User do
+  it { should ensure_valid_uuid_format_of(:uuid) }
+  it { should_not ensure_valid_uuid_format_of(:name) }
+end
+```
+
 ## Contributing
 
 Your contribution is welcome.

data/config/locales/en.yml

@@ -3,87 +3,111 @@ en:
     messages:
       alpha: "is not a valid alpha characters"
       alpha_numeric: "is not a valid alpha-numeric characters"
+      base64: "is not a valid Base64 encode"
       boolean: "is not a valid boolean"
       credit_card: "is not a valid credit card"
       currency: "is not a valid currency"
+      cusip: "is not a valid CUSIP"
       email: "is not a valid email"
       equality: "is not %{operator} %{attr}"
+      gtin: "is not a valid GTIN"
       hex: "is not a valid hex color"
       imei: "is not a valid IMEI"
       ip: "is not a valid IP"
       isbn: "is not a valid ISBN"
+      isin: "is not a valid ISIN"
       longitude: "is not a valid latitude"
       longitude: "is not a valid longitude"
       mac_address: "is not a valid MAC address"
       name: "is not a valid name"
       password: "is not a valid password"
       phone: "is not a valid phone number"
+      sedol: "is not a valid SEDOL"
       slug: "is not a valid slug"
       ssn: "is not a valid social security number"
       url: "is not a valid URL"
       username: "is not a valid username"
+      uuid: "is not a valid UUID"
   flash_validators:
     matchers:
       ensure_valid_alpha_format_of:
-        failure_message_for_should: "#{model} should ensure valid alpha format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid alpha format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid alpha format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid alpha format of attribute %{attr}"
       ensure_valid_alpha_numeric_format_of:
-        failure_message_for_should: "#{model} should ensure valid alpha numeric format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid alpha numeric format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid alpha numeric format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid alpha numeric format of attribute %{attr}"
+      ensure_valid_base64_format_of:
+        failure_message_for_should: "%{model} should ensure valid Base64 encoded format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid Base64 encoded format of attribute %{attr}"
       ensure_valid_boolean_format_of:
-        failure_message_for_should: "#{model} should ensure valid boolean format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid boolean format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid boolean format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid boolean format of attribute %{attr}"
       ensure_valid_credit_card_format_of:
-        failure_message_for_should: "#{model} should ensure valid credit card format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid credit card format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid credit card format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid credit card format of attribute %{attr}"
       ensure_valid_currency_format_of:
-        failure_message_for_should: "#{model} should ensure valid currency format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid currency format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid currency format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid currency format of attribute %{attr}"
+      ensure_valid_cusip_format_of:
+        failure_message_for_should: "%{model} should ensure valid CUSIP format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid CUSIP format of attribute %{attr}"
       ensure_valid_email_format_of:
-        failure_message_for_should: "#{model} should ensure valid email format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid email format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid email format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid email format of attribute %{attr}"
       ensure_valid_equality_format_of:
-        failure_message_for_should: "#{model} should ensure equality of #{operator} on attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure equality of #{operator} on attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure equality of %{operator} on attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure equality of %{operator} on attribute %{attr}"
+      ensure_valid_gtin_format_of:
+        failure_message_for_should: "%{model} should ensure valid GTIN format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid GTIN format of attribute %{attr}"
       ensure_valid_hex_format_of:
-        failure_message_for_should: "#{model} should ensure valid hex format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid hex format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid hex format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid hex format of attribute %{attr}"
       ensure_valid_imei_format_of:
-        failure_message_for_should: "#{model} should ensure valid IMEI address format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid IMEI address format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid IMEI address format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid IMEI address format of attribute %{attr}"
       ensure_valid_ip_format_of:
-        failure_message_for_should: "#{model} should ensure valid IP address format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid IP address format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid IP address format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid IP address format of attribute %{attr}"
       ensure_valid_isbn_format_of:
-        failure_message_for_should: "#{model} should ensure valid ISBN format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid ISBN format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid ISBN format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid ISBN format of attribute %{attr}"
+      ensure_valid_isin_format_of:
+        failure_message_for_should: "%{model} should ensure valid ISIN format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid ISIN format of attribute %{attr}"
       ensure_valid_latitude_format_of:
-        failure_message_for_should: "#{model} should ensure valid latitude format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid latitude format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid latitude format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid latitude format of attribute %{attr}"
       ensure_valid_longitude_format_of:
-        failure_message_for_should: "#{model} should ensure valid longitude format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid longitude format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid longitude format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid longitude format of attribute %{attr}"
       ensure_valid_mac_address_format_of:
-        failure_message_for_should: "#{model} should ensure valid MAC address format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid MAC address format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid MAC address format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid MAC address format of attribute %{attr}"
       ensure_valid_name_format_of:
-        failure_message_for_should: "#{model} should ensure valid name format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid name format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid name format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid name format of attribute %{attr}"
       ensure_valid_password_format_of:
-        failure_message_for_should: "#{model} should ensure valid password format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid password format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid password format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid password format of attribute %{attr}"
       ensure_valid_phone_format_of:
-        failure_message_for_should: "#{model} should ensure valid phone format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid phone format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid phone format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid phone format of attribute %{attr}"
+      ensure_valid_sedol_format_of:
+        failure_message_for_should: "%{model} should ensure valid SEDOL format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid SEDOL format of attribute %{attr}"
       ensure_valid_slug_format_of:
-        failure_message_for_should: "#{model} should ensure valid slug format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid slug format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid slug format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid slug format of attribute %{attr}"
       ensure_valid_ssn_format_of:
-        failure_message_for_should: "#{model} should ensure valid ssn format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid ssn format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid SSN format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid SSN format of attribute %{attr}"
       ensure_valid_url_format_of:
-        failure_message_for_should: "#{model} should ensure valid URL format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid URL format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid URL format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid URL format of attribute %{attr}"
       ensure_valid_username_format_of:
-        failure_message_for_should: "#{model} should ensure valid username format of attribute #{attr}"
-        failure_message_for_should_not: "#{model} should not ensure valid username format of attribute #{attr}"
+        failure_message_for_should: "%{model} should ensure valid username format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid username format of attribute %{attr}"
+      ensure_valid_uuid_format_of:
+        failure_message_for_should: "%{model} should ensure valid UUID format of attribute %{attr}"
+        failure_message_for_should_not: "%{model} should not ensure valid UUID format of attribute %{attr}"

data/lib/flash_validators/matchers/ensure_valid_alpha_format_of.rb

@@ -9,10 +9,18 @@ RSpec::Matchers.define :ensure_valid_alpha_format_of do |attribute|
   end
 
   failure_message do |model|
-    I18n.t('flash_validators.matchers.ensure_valid_alpha_format_of.failure_message_for_should', model: model.class)
+    I18n.t(
+      'flash_validators.matchers.ensure_valid_alpha_format_of.failure_message_for_should',
+      attr: attribute.inspect,
+      model: model.class.name
+    )
   end
 
   failure_message_when_negated do |model|
-    I18n.t('flash_validators.matchers.ensure_valid_alpha_format_of.failure_message_for_should_not', model: model.class)
+    I18n.t(
+      'flash_validators.matchers.ensure_valid_alpha_format_of.failure_message_for_should_not',
+      attr: attribute.inspect,
+      model: model.class.name
+    )
   end
 end

data/lib/flash_validators/matchers/ensure_valid_alpha_numeric_format_of.rb

@@ -9,10 +9,18 @@ RSpec::Matchers.define :ensure_valid_alpha_numeric_format_of do |attribute|
   end
 
   failure_message do |model|
-    I18n.t('flash_validators.matchers.ensure_valid_alpha_numeric_format_of.failure_message_for_should', model: model.class)
+    I18n.t(
+      'flash_validators.matchers.ensure_valid_alpha_numeric_format_of.failure_message_for_should',
+      attr: attribute.inspect,
+      model: model.class.name
+    )
   end
 
   failure_message_when_negated do |model|
-    I18n.t('flash_validators.matchers.ensure_valid_alpha_numeric_format_of.failure_message_for_should_not', model: model.class)
+    I18n.t(
+      'flash_validators.matchers.ensure_valid_alpha_numeric_format_of.failure_message_for_should_not',
+      attr: attribute.inspect,
+      model: model.class.name
+    )
   end
 end

data/lib/flash_validators/matchers/ensure_valid_base64_format_of.rb

@@ -0,0 +1,26 @@
+RSpec::Matchers.define :ensure_valid_base64_format_of do |attribute|
+  match do |model|
+    model.send("#{attribute}=", "1a.b2==")
+    model.valid?
+
+    if model.errors.has_key?(attribute)
+      model.errors[attribute].include?(I18n.t('errors.messages.base64'))
+    end
+  end
+
+  failure_message do |model|
+    I18n.t(
+      'flash_validators.matchers.ensure_valid_base64_format_of.failure_message_for_should',
+      attr: attribute.inspect,
+      model: model.class.name
+    )
+  end
+
+  failure_message_when_negated do |model|
+    I18n.t(
+      'flash_validators.matchers.ensure_valid_base64_format_of.failure_message_for_should_not',
+      attr: attribute.inspect,
+      model: model.class.name
+    )
+  end
+end