internationalize 0.2.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfc56411ee42ac5d8377fe409418e1692acc4cb0c5cd60899acd70003f0d4dd7
-  data.tar.gz: 9a437ba5771695b1d84b7d95e61d4df4e342725501df6dc947809245750054a9
+  metadata.gz: 0a7c08fb66904ff4e73e13f590f4546af940ce8f9adc59d870adf60e71f54fc0
+  data.tar.gz: e6e5b34d18588fc2b8d1fd18b182d73f39bffe2ad67c7f383976eaa30d8b6ee2
 SHA512:
-  metadata.gz: 4354ea3355e467ebfc465feacdb707189b5981f6df04e8620e8b72dbf4c84f4df8e2d454e3a405f0ffd7c923ec4c8c946f119241b99ddf978d700fbeebb1ecbf
-  data.tar.gz: 82e139593ed3296be30e601376b147cfaf2690255f25c2be69b7add169568b388ad721bd14a0f6244489987e4bbf9fc4a89f303a8c87a1f94eca99f5e524b8b0
+  metadata.gz: 6bf2d4d4e0cfcb36adbd787f3a839dd6bbe4290468eb2934b99af4c4541d948aef7d3f5ea71329e2f99aabe1f2530c83af8955d544d8991e0a9341b4abd393cb
+  data.tar.gz: 5ccafbadb398e1ad9b956990b10334c80577f248d32b4e788a94dc5ad39fffdb47fa1c22eb892216af71784ea4770b4d0bfac43ceeaac951cff63575a4ce1152

data/CHANGELOG.md

@@ -5,7 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.4.0] - 2025-12-02
+
+### Added
+
+- `i18n_where` query method as a short, convenient alias for querying translated attributes
+  - `Article.i18n_where(title: "Hello")` - exact match
+  - `Article.i18n_where(title: "hello", match: :partial)` - LIKE match
+
+### Deprecated
+
+- Using `international` for querying is now deprecated; use `i18n_where` or `international_where` instead
+  - A deprecation warning is now emitted when using `international` for queries
+
+## [0.3.0] - 2024-12-01
+
+### Added
+
+- `validates_international` method for locale-specific validations:
+  - `uniqueness: true` - validates uniqueness per-locale (requires JSON column querying)
+  - `presence: { locales: [:en, :de] }` - requires translations for specific locales (useful for admin interfaces)
+- Standard Rails validations (`validates :title, presence: true`) now work with virtual accessors
+- `international_where` query method as a clearer alternative to `international` for queries
 
 ## [0.2.4] - 2024-11-29
 

data/README.md

@@ -1,21 +1,27 @@
 # Internationalize
 
+[![Gem Version](https://badge.fury.io/rb/internationalize.svg)](https://rubygems.org/gems/internationalize)
+[![Build](https://github.com/sampokuokkanen/internationalize/workflows/CI/badge.svg)](https://github.com/sampokuokkanen/internationalize/actions)
+
 Lightweight, performant internationalization for Rails with JSON column storage.
 
 ## Why Internationalize?
 
 Internationalize is a focused, lightweight gem that does one thing well: JSON column translations. No backend abstraction layers, no plugin systems, no extra memory overhead.
 
-Unlike Globalize or Mobility which use separate translation tables requiring JOINs, Internationalize stores translations inline using JSON columns. This means:
+Unlike Globalize (separate translation tables) or Mobility (JSON backend is PostgreSQL-only), Internationalize stores translations inline using JSON columns with **full SQLite, PostgreSQL, and MySQL support**:
 
 - **No JOINs** - translations live in the same table
 - **No N+1 queries** - data is always loaded with the record
 - **No backend overhead** - direct JSON column access, no abstraction layers
 - **~50% less memory** - no per-instance backend objects or plugin chains
 - **Direct method dispatch** - no `method_missing` overhead
-- **Multi-database support** - works with SQLite, PostgreSQL, and MySQL
+- **True multi-database JSON support** - SQLite 3.38+, PostgreSQL 9.4+, MySQL 8.0+
+- **ActionText support** - internationalized rich text with attachments
 - **Visible in schema.rb** - translated fields appear directly in your model's schema
 
+> **Note:** Mobility's JSON/JSONB backends only work with PostgreSQL. For SQLite or MySQL, Mobility requires separate translation tables with JOINs. Internationalize provides JSON column querying across all three databases.
+
 ## Supported Databases
 
 | Database | JSON Column | Query Syntax |
@@ -113,13 +119,12 @@ All query methods default to the current `I18n.locale` and return ActiveRecord r
 
 ```ruby
 # Exact match on translation (uses current locale by default)
-Article.international(title: "Hello World")
-Article.international(title: "Hallo Welt", locale: :de)
+Article.i18n_where(title: "Hello World")
+Article.i18n_where(title: "Hallo Welt", locale: :de)
 
 # Partial match / search (case-insensitive LIKE)
-Article.international(title: "hello", match: :partial)
-Article.international(title: "Hello", match: :partial, case_sensitive: true)
-Article.international(title: "hallo", match: :partial, locale: :de)
+Article.i18n_where(title: "hello", match: :partial)
+Article.i18n_where(title: "Hello", match: :partial, case_sensitive: true)
 
 # Exclude matches
 Article.international_not(title: "Draft")
@@ -136,19 +141,15 @@ Article.translated(:title, locale: :de)
 Article.untranslated(:title, locale: :de)
 
 # Chain with ActiveRecord methods
-Article.international(title: "Hello World")
+Article.i18n_where(title: "Hello World")
        .where(published: true)
        .includes(:author)
        .limit(10)
 
 # Combine queries
-Article.international(title: "hello", match: :partial)
+Article.i18n_where(title: "hello", match: :partial)
        .where(status: "published")
        .merge(Article.international_order(:title, :desc))
-
-# Query across multiple locales
-Article.international(title: "Hello World", locale: :en)
-       .merge(Article.international(title: "Hallo Welt", locale: :de))
 ```
 
 ### Helper Methods
@@ -173,9 +174,46 @@ I18n.locale = :de
 article.title  # => "Hello" (falls back to :en)
 ```
 
+### Validations
+
+For most validations, use standard Rails validators—they work with the virtual accessor for the current locale:
+
+```ruby
+class Article < ApplicationRecord
+  include Internationalize::Model
+  international :title
+
+  # Standard Rails validations (recommended)
+  validates :title, presence: true
+  validates :title, length: { minimum: 3, maximum: 100 }
+  validates :title, format: { with: /\A[a-z0-9-]+\z/ }
+end
+```
+
+Use `validates_international` only when you need:
+
+```ruby
+class Article < ApplicationRecord
+  include Internationalize::Model
+  international :title
+
+  # Uniqueness per-locale (requires JSON column querying)
+  validates_international :title, uniqueness: true
+
+  # Multi-locale presence (for admin interfaces editing all translations at once)
+  validates_international :title, presence: { locales: [:en, :de] }
+end
+```
+
+Errors from `validates_international` are added to locale-specific keys:
+
+```ruby
+article.errors[:title_en]  # => ["has already been taken"]
+```
+
 ### ActionText Support
 
-For rich text with attachments, use `international_rich_text` (auto-loaded when ActionText is available):
+For rich text with attachments (requires ActionText):
 
 ```ruby
 class Article < ApplicationRecord
@@ -211,15 +249,20 @@ hello_world:
 
 ## Configuration
 
+No configuration required. Internationalize uses your existing Rails I18n settings:
+
+- **Locales**: `I18n.available_locales`
+- **Fallback**: `I18n.default_locale`
+
+To override locales (rarely needed):
+
 ```ruby
 # config/initializers/internationalize.rb
 Internationalize.configure do |config|
-  config.available_locales = [:en, :de, :fr]  # Defaults to I18n.available_locales
+  config.available_locales = [:en, :de, :fr]
 end
 ```
 
-Fallback uses `I18n.default_locale` automatically.
-
 ## Performance Comparison
 
 Benchmark with 1000 records, 2 translated attributes (title + body), 3 locales:
@@ -250,13 +293,13 @@ Benchmark with 1000 records, 2 translated attributes (title + body), 3 locales:
 
 ### When to consider Mobility
 
-For table-based translation storage, consider [Mobility](https://github.com/shioyama/mobility) instead:
+Consider [Mobility](https://github.com/shioyama/mobility) if:
 
-- Existing projects with large tables where adding columns is expensive
-- When you need to add translations without modifying existing table schemas
-- Applications that rarely query by translated content
+- You need to add translations without modifying existing table schemas
+- You're on PostgreSQL and want their JSON backend (note: PostgreSQL-only)
+- You need the flexibility of multiple backend strategies
 
-Mobility's table backend stores translations in separate tables with JOINs, which trades query performance for schema flexibility.
+Mobility's table backend stores translations in separate tables with JOINs, which trades query performance for schema flexibility. Their JSON backend is PostgreSQL-only.
 
 ## License
 

data/context/configuration.md

@@ -1,17 +1,21 @@
 # Internationalize: Configuration
 
-## Global Configuration
+## Zero Configuration
+
+No configuration required. Internationalize uses your existing Rails I18n settings:
+
+- `I18n.available_locales` - determines which locale accessors are generated
+- `I18n.default_locale` - used for fallback when translation is missing
+
+## Override Locales (Rarely Needed)
 
 ```ruby
 # config/initializers/internationalize.rb
 Internationalize.configure do |config|
-  # Override available locales (defaults to I18n.available_locales)
   config.available_locales = [:en, :de, :fr, :es]
 end
 ```
 
-Fallback locale is always `I18n.default_locale`.
-
 ## Database Setup
 
 Use the generator to create migrations:

data/context/getting-started.md

@@ -71,10 +71,10 @@ article.title_translations  # => {"en" => "Hello World", "de" => "Hallo Welt"}
 
 ```ruby
 # Exact match
-Article.international(title: "Hello World")
+Article.i18n_where(title: "Hello World")
 
 # Partial match (LIKE)
-Article.international(title: "Hello", match: :partial)
+Article.i18n_where(title: "Hello", match: :partial)
 
 # Order by translation
 Article.international_order(:title, :desc)

data/context/model-api.md

@@ -49,17 +49,17 @@ All query methods default to current `I18n.locale` and return `ActiveRecord::Rel
 
 | Method | Description |
 |--------|-------------|
-| `international(**conditions, locale: nil)` | Exact match query |
+| `i18n_where(**conditions, locale: nil, match: :exact)` | Query by translation (short alias) |
+| `international_where(**conditions, locale: nil, match: :exact)` | Query by translation |
 | `international_not(**conditions, locale: nil)` | Exclude matching records |
-| `international_search(**conditions, locale: nil, case_sensitive: false)` | Substring search |
 | `international_order(attr, dir = :asc, locale: nil)` | Order by translation |
 | `translated(*attrs, locale: nil)` | Find records with translation |
 | `untranslated(*attrs, locale: nil)` | Find records missing translation |
 
 ```ruby
 # Examples
-Article.international(title: "Hello World")
-Article.international_search(title: "hello", locale: :de)
+Article.i18n_where(title: "Hello World")
+Article.i18n_where(title: "hello", match: :partial)  # case-insensitive LIKE
 Article.international_order(:title, :desc)
 Article.translated(:title, locale: :de)
 ```
@@ -80,14 +80,66 @@ I18n.locale = :de
 article.title  # => "Hello" (falls back to default locale)
 ```
 
+## Validations
+
+For most validations, use standard Rails validators—they work with the virtual accessor:
+
+```ruby
+class Article < ApplicationRecord
+  include Internationalize::Model
+  international :title
+
+  # Standard Rails validations (recommended)
+  validates :title, presence: true
+  validates :title, length: { minimum: 3, maximum: 100 }
+  validates :title, format: { with: /\A[a-z]+\z/ }
+end
+```
+
+Use `validates_international` only for uniqueness or multi-locale presence:
+
+```ruby
+class Article < ApplicationRecord
+  include Internationalize::Model
+  international :title
+
+  # Uniqueness per-locale (requires JSON column querying)
+  validates_international :title, uniqueness: true
+
+  # Multi-locale presence (for admin interfaces editing all translations at once)
+  validates_international :title, presence: { locales: [:en, :de] }
+end
+```
+
+### Validation Options
+
+| Option | Description |
+|--------|-------------|
+| `uniqueness: true` | Validates uniqueness per-locale (current locale) |
+| `presence: { locales: [:en, :de] }` | Requires translations for specific locales |
+
+### Error Keys
+
+Standard Rails validations add errors to the virtual attribute:
+
+```ruby
+article.errors[:title]  # => ["can't be blank"]
+```
+
+`validates_international` adds errors to locale-specific keys:
+
+```ruby
+article.errors[:title_en]  # => ["has already been taken"]
+```
+
 ## ActionText Support
 
-For rich text with attachments, use `international_rich_text` (auto-loaded when ActionText is available):
+For rich text with attachments, include `Internationalize::RichText` and use `international_rich_text`:
 
 ```ruby
 class Article < ApplicationRecord
   include Internationalize::Model
-  include Internationalize::RichText
+  include Internationalize::RichText  # Requires ActionText
 
   international_rich_text :content
 end

data/context/query-api.md

@@ -8,47 +8,40 @@ All query methods default to the current `I18n.locale`. Use the `locale:` option
 
 ```ruby
 # Uses current I18n.locale
-Article.international(title: "Hello World")
+Article.i18n_where(title: "Hello World")
 
 # Explicit locale
-Article.international(title: "Hallo Welt", locale: :de)
+Article.i18n_where(title: "Hallo Welt", locale: :de)
 ```
 
 ## Query Methods
 
-### international(**conditions, locale: nil)
+### i18n_where(**conditions, locale: nil, match: :exact, case_sensitive: false)
 
-Exact match on translated attributes:
+Query by translated attributes. Also available as `international_where`.
+
+Exact match (default):
 
 ```ruby
-Article.international(title: "Hello World")
-Article.international(title: "Hello", status: "published")
-Article.international(title: "Hallo Welt", locale: :de)
+Article.i18n_where(title: "Hello World")
+Article.i18n_where(title: "Hello", status: "published")
+Article.i18n_where(title: "Hallo Welt", locale: :de)
 ```
 
-### international_not(**conditions, locale: nil)
-
-Exclude records matching conditions:
+Partial match (case-insensitive LIKE):
 
 ```ruby
-Article.international_not(title: "Draft")
-Article.international_not(title: "Entwurf", locale: :de)
+Article.i18n_where(title: "hello", match: :partial)
+Article.i18n_where(title: "Hello", match: :partial, case_sensitive: true)
 ```
 
-### international_search(**conditions, locale: nil, case_sensitive: false)
+### international_not(**conditions, locale: nil)
 
-Substring search (LIKE/ILIKE):
+Exclude records matching conditions:
 
 ```ruby
-# Case-insensitive (default)
-Article.international_search(title: "hello")
-Article.international_search(title: "hello", description: "world")
-
-# Case-sensitive
-Article.international_search(title: "Hello", case_sensitive: true)
-
-# With explicit locale
-Article.international_search(title: "welt", locale: :de)
+Article.international_not(title: "Draft")
+Article.international_not(title: "Entwurf", locale: :de)
 ```
 
 ### international_order(attribute, direction = :asc, locale: nil)
@@ -85,7 +78,7 @@ Article.untranslated(:title, locale: :de)
 All methods return `ActiveRecord::Relation`, so they chain naturally with AR methods:
 
 ```ruby
-Article.international(title: "Hello World")
+Article.i18n_where(title: "Hello World")
        .where(published: true)
        .order(created_at: :desc)
        .limit(10)
@@ -98,20 +91,20 @@ Use `merge` to combine multiple international queries:
 
 ```ruby
 # Search + filter + order
-Article.international_search(title: "hello")
-       .merge(Article.international(status: "published"))
+Article.i18n_where(title: "hello", match: :partial)
+       .merge(Article.i18n_where(status: "published"))
        .merge(Article.international_order(:title, :desc))
 
 # Query across multiple locales
-Article.international(title: "Hello World", locale: :en)
-       .merge(Article.international(title: "Hallo Welt", locale: :de))
+Article.i18n_where(title: "Hello World", locale: :en)
+       .merge(Article.i18n_where(title: "Hallo Welt", locale: :de))
 ```
 
 ## Examples
 
 ```ruby
 # Find published articles with German title containing "Welt"
-Article.international_search(title: "Welt", locale: :de)
+Article.i18n_where(title: "Welt", match: :partial, locale: :de)
        .where(published: true)
        .merge(Article.international_order(:title, locale: :de))
        .limit(10)

data/lib/internationalize/model.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "validations"
+
 module Internationalize
   # Mixin for ActiveRecord models to enable internationalization
   #
@@ -10,12 +12,13 @@ module Internationalize
   #   end
   #
   #   # Querying
-  #   Article.international(title: "Hello")
-  #   Article.international(title: "hello", match: :partial)
+  #   Article.i18n_where(title: "Hello")
+  #   Article.i18n_where(title: "hello", match: :partial)
   #   Article.international_order(:title, :desc)
   #
   module Model
     extend ActiveSupport::Concern
+    include Internationalize::Validations
 
     VALID_DIRECTIONS = ["ASC", "DESC"].freeze
 
@@ -24,33 +27,57 @@ module Internationalize
     end
 
     class_methods do
-      # Declares attributes as internationalized OR queries by translated attributes
+      # Declares attributes as internationalized
       #
-      # When called with Symbol arguments, declares attributes as internationalized:
+      # @example
       #   international :title, :description
       #
-      # When called with keyword arguments, queries translated attributes:
-      #   Article.international(title: "Hello")                      # exact match
-      #   Article.international(title: "Hello", locale: :de)         # exact match in German
-      #   Article.international(title: "hello", match: :partial)     # LIKE match (case-insensitive)
-      #   Article.international(title: "Hello", match: :partial, case_sensitive: true)
-      #
       # @param attributes [Array<Symbol>] attributes to declare as internationalized
-      # @param locale [Symbol] locale to query (default: current locale)
-      # @param match [Symbol] :exact or :partial (default: :exact)
-      # @param case_sensitive [Boolean] for partial matching only (default: false)
-      # @param conditions [Hash] attribute => value pairs to query
+      #
+      # @deprecated Using this method for querying is deprecated.
+      #   Use {#i18n_where} or {#international_where} instead.
       #
       def international(*attributes, locale: nil, match: :exact, case_sensitive: false, **conditions)
         if attributes.any? && attributes.first.is_a?(Symbol) && conditions.empty?
           # Declaration mode: international :title, :description
           declare_international_attributes(attributes)
         else
-          # Query mode: Article.international(title: "Hello")
+          # Query mode: Article.international(title: "Hello") - DEPRECATED
+          warn("[Internationalize] DEPRECATION WARNING: Using `international` for querying is deprecated. " \
+            "Use `i18n_where` or `international_where` instead. " \
+            "(called from #{caller(1..1).first})")
           international_query(conditions, locale: locale, match: match, case_sensitive: case_sensitive)
         end
       end
 
+      # Query translated attributes
+      #
+      # @param conditions [Hash] attribute => value pairs to query
+      # @param locale [Symbol] locale to query (default: current locale)
+      # @param match [Symbol] :exact or :partial (default: :exact)
+      # @param case_sensitive [Boolean] for partial matching only (default: false)
+      # @return [ActiveRecord::Relation]
+      #
+      # @example
+      #   Article.international_where(title: "Hello")
+      #   Article.international_where(title: "hello", match: :partial)
+      #
+      def international_where(locale: nil, match: :exact, case_sensitive: false, **conditions)
+        international_query(conditions, locale: locale, match: match, case_sensitive: case_sensitive)
+      end
+
+      # Short alias for international_where
+      #
+      # @see #international_where
+      #
+      # @example
+      #   Article.i18n_where(title: "Hello")
+      #   Article.i18n_where(title: "hello", match: :partial)
+      #
+      def i18n_where(locale: nil, match: :exact, case_sensitive: false, **conditions)
+        international_query(conditions, locale: locale, match: match, case_sensitive: case_sensitive)
+      end
+
       # Order by translated attribute
       #
       # @param attribute [Symbol] attribute to order by
@@ -334,7 +361,7 @@ module Internationalize
           hash.each_key do |key|
             unless allowed_locales.include?(key.to_s)
               raise ArgumentError, "Invalid locale '#{key}' for #{attr}_translations. " \
-                "Allowed locales: #{allowed_locales.join(', ')}"
+                "Allowed locales: #{allowed_locales.join(", ")}"
             end
           end
 
@@ -351,7 +378,7 @@ module Internationalize
 
           if locale_str.include?("-")
             raise ArgumentError, "Locale '#{locale}' contains a hyphen which is invalid for Ruby method names. " \
-              "Use underscore format instead: :#{locale_str.tr('-', '_')}"
+              "Use underscore format instead: :#{locale_str.tr("-", "_")}"
           end
 
           getter_method = :"#{attr}_#{locale}"

data/lib/internationalize/rich_text.rb

@@ -31,7 +31,7 @@ module Internationalize
           locale_str = locale.to_s
           if locale_str.include?("-")
             raise ArgumentError, "Locale '#{locale}' contains a hyphen which is invalid for Ruby method names. " \
-              "Use underscore format instead: :#{locale_str.tr('-', '_')}"
+              "Use underscore format instead: :#{locale_str.tr("-", "_")}"
           end
         end
 

data/lib/internationalize/validations.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Internationalize
+  # Validation support for internationalized attributes
+  #
+  # For simple validations (presence, length, format), use standard Rails validations
+  # which work with the virtual accessor for the current locale:
+  #
+  #   validates :title, presence: true
+  #   validates :title, length: { minimum: 3 }
+  #
+  # Use validates_international for:
+  # - Uniqueness (requires JSON column querying)
+  # - Multi-locale presence (admin interfaces editing all translations at once)
+  #
+  # @example Uniqueness per-locale
+  #   validates_international :title, uniqueness: true
+  #
+  # @example Require specific locales (admin/manager interfaces)
+  #   validates_international :title, presence: { locales: [:en, :de] }
+  #
+  module Validations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Validates internationalized attributes
+      #
+      # @param attrs [Array<Symbol>] attribute names to validate
+      # @param options [Hash] validation options
+      # @option options [Boolean] :uniqueness validate uniqueness per-locale (current locale)
+      # @option options [Hash] :presence with :locales array for multi-locale presence
+      #
+      # @example Uniqueness validation (per-locale)
+      #   validates_international :title, uniqueness: true
+      #
+      # @example Multi-locale presence (for admin interfaces)
+      #   validates_international :title, presence: { locales: [:en, :de] }
+      #
+      def validates_international(*attrs, **options)
+        presence_opts = options.delete(:presence)
+        uniqueness_opts = options.delete(:uniqueness)
+
+        attrs.each do |attr|
+          validate_international_presence(attr, presence_opts) if presence_opts
+          validate_international_uniqueness(attr, uniqueness_opts) if uniqueness_opts
+        end
+      end
+
+      private
+
+      def validate_international_presence(attr, options)
+        unless options.is_a?(Hash) && options[:locales]
+          raise ArgumentError, "validates_international presence requires locales: option. " \
+            "For current locale, use: validates :#{attr}, presence: true"
+        end
+
+        locales = options[:locales].map(&:to_s)
+
+        validate do |record|
+          locales.each do |locale|
+            value = record.send("#{attr}_#{locale}")
+            if value.blank?
+              record.errors.add("#{attr}_#{locale}", :blank)
+            end
+          end
+        end
+      end
+
+      def validate_international_uniqueness(attr, _options)
+        validate do |record|
+          locale = I18n.locale.to_s
+          value = record.send("#{attr}_#{locale}")
+          next if value.blank?
+
+          scope = record.class.international(attr => value, locale: locale)
+          scope = scope.where.not(id: record.id) if record.persisted?
+
+          if scope.exists?
+            record.errors.add("#{attr}_#{locale}", :taken)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/internationalize/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Internationalize
-  VERSION = "0.2.4"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: internationalize
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Sampo Kuokkanen
@@ -64,6 +64,7 @@ files:
 - lib/internationalize/adapters/sqlite.rb
 - lib/internationalize/model.rb
 - lib/internationalize/rich_text.rb
+- lib/internationalize/validations.rb
 - lib/internationalize/version.rb
 homepage: https://github.com/sampokuokkanen/internationalize
 licenses: