internationalize 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ba5df71bafb02b68108aed602ac75ad4ced036109e49dbd40dc90354a7c351a
-  data.tar.gz: d39b4232e8b76511d1a409d6848fa98e8f60f8f9523b62985c467cb2767ec7e3
+  metadata.gz: 520c17d4993a0145c00081a95a30f21c9a3b56b0879589fc87f4731564be7f1e
+  data.tar.gz: 24478d271a6500c4104c8e26db4238ed1857b533b25e5c351e30cfc45fe7c13a
 SHA512:
-  metadata.gz: 8ff4adb5021405380a123cc1cc06b8dd3818851e32570ae90e7bdf776f566bbc9ff6504ab26960dae909109550444875aaca42d3cf988ae4393b18c05628e292
-  data.tar.gz: 8d2643b882281a39f0446d274b25321be03909c2ba41510a75a4e498918fc0ee37a59abae42e373e246a4d1b1f1ebeefdb5ec9e12e29d8a81a13c3d05f9478a6
+  metadata.gz: a15ca8db8848c85feec7d912c47905a0cbd665aed43721642b97e039f607699edbeb207666d3af98e92e412d6c6ac0c89298b4ac4aba5c9643bf2554c2f59a08
+  data.tar.gz: b380cf31e89bd26994935e733c89df8b23771e83a73606f39dd6092f833aec11f0a4e471ec8c8c8ff914cd3079a15b0d05a4d016962936adc707302acaec5683

data/CHANGELOG.md

@@ -5,6 +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.2.0] - 2024-11-29
+
+### Added
+
+- ActionText support via `international_rich_text` (optional, requires ActionText)
+  - Generates `has_rich_text` for each locale with unified accessor
+  - Full attachment support per locale
+
+### Removed
+
+- `fallback: false` option - translations now always fallback to default locale
+- `set_translation(attr, locale, value)` - use `title_de = "value"` instead
+- `translation_for(attr, locale)` - use `title_de` instead
+
+## [0.1.1] - 2024-11-29
+
+### Fixed
+
+- Include `context/` directory in gem for `bake agent:context:install` support
+
 ## [0.1.0] - 2024-11-29
 
 ### Added
@@ -28,7 +50,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - `translation_for(attr, locale)`
   - `translated?(attr, locale)`
   - `translated_locales(attr)`
-- Fallback to default locale when translation missing (configurable)
+- Fallback to default locale when translation missing
 - SQLite adapter using `json_extract()`
 - PostgreSQL adapter using `->>` operator
 - MySQL 8+ adapter using `->>` operator (supports mysql2 and trilogy gems)

data/README.md

@@ -4,10 +4,14 @@ 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:
 
 - **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
 - **Visible in schema.rb** - translated fields appear directly in your model's schema
@@ -155,10 +159,6 @@ article.translated?(:title, :de)  # => true/false
 
 # Get all translated locales for an attribute
 article.translated_locales(:title)  # => [:en, :de]
-
-# Set/get translation for specific locale
-article.set_translation(:title, :de, "Hallo Welt")
-article.translation_for(:title, :de)  # => "Hallo Welt"
 ```
 
 ### Fallbacks
@@ -173,10 +173,29 @@ I18n.locale = :de
 article.title  # => "Hello" (falls back to :en)
 ```
 
-Disable fallbacks:
+### ActionText Support
+
+For rich text with attachments, use `international_rich_text` (requires ActionText):
 
 ```ruby
-international :title, fallback: false
+require "internationalize/rich_text"
+
+class Article < ApplicationRecord
+  include Internationalize::Model
+  include Internationalize::RichText
+
+  international_rich_text :content
+end
+```
+
+This generates `has_rich_text :content_en`, `has_rich_text :content_de`, etc. for each locale, with a unified accessor:
+
+```ruby
+article.content = "<p>Hello</p>"     # Sets for current locale
+article.content                       # Gets for current locale (with fallback)
+article.content_en                    # Direct access to English
+article.content.body                  # ActionText::Content object
+article.content.embeds                # Attachments work per-locale
 ```
 
 ## Configuration
@@ -184,11 +203,12 @@ international :title, fallback: false
 ```ruby
 # config/initializers/internationalize.rb
 Internationalize.configure do |config|
-  config.fallback_locale = :en
-  config.available_locales = [:en, :de, :fr]
+  config.available_locales = [:en, :de, :fr]  # Defaults to I18n.available_locales
 end
 ```
 
+Fallback uses `I18n.default_locale` automatically.
+
 ## Performance Comparison
 
 Benchmark with 1000 records, 2 translated attributes (title + body), 3 locales:

data/context/configuration.md

@@ -0,0 +1,66 @@
+# Internationalize: Configuration
+
+## Global Configuration
+
+```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:
+
+```bash
+rails generate internationalize:translation Article title description
+```
+
+Or create migrations manually:
+
+### SQLite / MySQL
+
+```ruby
+class AddTranslationsToArticles < ActiveRecord::Migration[7.1]
+  def change
+    add_column :articles, :title_translations, :json, default: {}
+  end
+end
+```
+
+### PostgreSQL
+
+For better query performance, use `jsonb`:
+
+```ruby
+class AddTranslationsToArticles < ActiveRecord::Migration[7.1]
+  def change
+    add_column :articles, :title_translations, :jsonb, default: {}
+
+    # Optional: Add GIN index for faster queries
+    add_index :articles, :title_translations, using: :gin
+  end
+end
+```
+
+## Supported Databases
+
+| Database | Minimum Version | JSON Type | Query Syntax |
+|----------|-----------------|-----------|--------------|
+| SQLite | 3.38+ | `json` | `json_extract()` |
+| PostgreSQL | 9.4+ | `json`/`jsonb` | `->>` operator |
+| MySQL | 8.0+ | `json` | `->>` operator |
+
+## I18n Integration
+
+Internationalize uses Rails I18n settings directly:
+
+```ruby
+I18n.locale           # Used for current locale
+I18n.default_locale   # Used for fallbacks
+I18n.available_locales # Used for locale-specific accessors (can be overridden)
+```

data/context/getting-started.md

@@ -0,0 +1,98 @@
+# Internationalize: Getting Started
+
+Internationalize is a lightweight internationalization gem for Rails that stores translations in JSON columns instead of separate tables.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "internationalize"
+```
+
+## Quick Setup
+
+### 1. Generate a migration for translation columns
+
+```bash
+rails generate internationalize:translation Article title description
+```
+
+This creates a migration adding `title_translations` and `description_translations` JSON columns.
+
+Or write the migration manually:
+
+```ruby
+class AddTranslationsToArticles < ActiveRecord::Migration[7.1]
+  def change
+    add_column :articles, :title_translations, :json, default: {}
+    add_column :articles, :description_translations, :json, default: {}
+  end
+end
+```
+
+### 2. Include the mixin and declare translatable attributes
+
+```ruby
+class Article < ApplicationRecord
+  include Internationalize::Model
+  international :title, :description
+end
+```
+
+### 3. Use translations
+
+```ruby
+# Create with translations (hash for multiple locales)
+Article.international_create!(
+  title: { en: "Hello World", de: "Hallo Welt" },
+  status: "published"
+)
+
+# Or direct string for current locale
+I18n.locale = :de
+Article.international_create!(title: "Achtung!")  # Sets title_de
+
+# Set translation for current locale
+article.title = "Hello World"
+
+# Set for specific locale
+article.title_en = "Hello World"
+article.title_de = "Hallo Welt"
+
+# Read translation
+article.title         # => uses I18n.locale
+article.title_de      # => "Hallo Welt"
+
+# Access raw hash
+article.title_translations  # => {"en" => "Hello World", "de" => "Hallo Welt"}
+```
+
+### 4. Query translations
+
+```ruby
+# Exact match
+Article.international(title: "Hello World")
+
+# Partial match (LIKE)
+Article.international(title: "Hello", match: :partial)
+
+# Order by translation
+Article.international_order(:title, :desc)
+```
+
+## Key Concepts
+
+- Translations stored in `*_translations` JSON columns
+- No JOINs - data lives in the same table
+- Automatic fallback to default locale
+- Works with SQLite, PostgreSQL, and MySQL
+
+## Important: Column Defaults
+
+JSON columns **must** have `default: {}` set in the migration. The generator does this automatically, but if writing migrations manually, ensure you include it:
+
+```ruby
+add_column :articles, :title_translations, :json, default: {}
+```
+
+This is required for optimal performance and correct behavior.

data/context/index.yaml

@@ -0,0 +1,14 @@
+description: "Lightweight, performant internationalization for Rails using JSON columns"
+files:
+  - path: getting-started.md
+    title: "Getting Started"
+    description: "Quick setup guide for Internationalize"
+  - path: model-api.md
+    title: "Model API"
+    description: "Model mixin methods and generated accessors"
+  - path: query-api.md
+    title: "Query API"
+    description: "Query methods for searching and filtering translations"
+  - path: configuration.md
+    title: "Configuration"
+    description: "Global and per-attribute configuration options"

data/context/model-api.md

@@ -0,0 +1,81 @@
+# Internationalize: Model API
+
+## Including the Mixin
+
+```ruby
+class Article < ApplicationRecord
+  include Internationalize::Model
+  international :title, :description
+end
+```
+
+## Generated Instance Methods
+
+For each `international :title` declaration:
+
+### Accessors
+
+| Method | Description |
+|--------|-------------|
+| `title` | Get translation for current `I18n.locale` |
+| `title=` | Set translation for current `I18n.locale` |
+| `title?` | Check if translation exists |
+| `title_translations` | Get raw hash of all translations |
+| `title_translations=` | Set all translations at once |
+
+### Locale-Specific Accessors
+
+For each locale in `I18n.available_locales`:
+
+| Method | Description |
+|--------|-------------|
+| `title_en` | Get English translation directly |
+| `title_en=` | Set English translation |
+| `title_en?` | Check if English translation exists |
+| `title_de` | Get German translation |
+| `title_de=` | Set German translation |
+| ... | etc. for all locales |
+
+### Instance Helper Methods
+
+| Method | Description |
+|--------|-------------|
+| `translated?(:title, :de)` | Check if translation exists |
+| `translated_locales(:title)` | Array of locales with translations |
+
+## Class Methods (Querying)
+
+All query methods default to current `I18n.locale` and return `ActiveRecord::Relation`:
+
+| Method | Description |
+|--------|-------------|
+| `international(**conditions, locale: nil)` | Exact match query |
+| `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.international_order(:title, :desc)
+Article.translated(:title, locale: :de)
+```
+
+## Class Attributes
+
+```ruby
+Article.international_attributes  # => [:title, :description]
+```
+
+## Fallback Behavior
+
+Translations automatically fall back to the default locale when missing:
+
+```ruby
+article.title_en = "Hello"
+I18n.locale = :de
+article.title  # => "Hello" (falls back to default locale)
+```

data/context/query-api.md

@@ -0,0 +1,129 @@
+# Internationalize: Query API
+
+All query methods are class methods on models that include `Internationalize::Model`. They return `ActiveRecord::Relation` objects that can be chained with standard AR methods.
+
+## Default Locale Behavior
+
+All query methods default to the current `I18n.locale`. Use the `locale:` option to override:
+
+```ruby
+# Uses current I18n.locale
+Article.international(title: "Hello World")
+
+# Explicit locale
+Article.international(title: "Hallo Welt", locale: :de)
+```
+
+## Query Methods
+
+### international(**conditions, locale: nil)
+
+Exact match on translated attributes:
+
+```ruby
+Article.international(title: "Hello World")
+Article.international(title: "Hello", status: "published")
+Article.international(title: "Hallo Welt", locale: :de)
+```
+
+### international_not(**conditions, locale: nil)
+
+Exclude records matching conditions:
+
+```ruby
+Article.international_not(title: "Draft")
+Article.international_not(title: "Entwurf", locale: :de)
+```
+
+### international_search(**conditions, locale: nil, case_sensitive: false)
+
+Substring search (LIKE/ILIKE):
+
+```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)
+```
+
+### international_order(attribute, direction = :asc, locale: nil)
+
+Order by translated attribute:
+
+```ruby
+Article.international_order(:title)
+Article.international_order(:title, :desc)
+Article.international_order(:title, :asc, locale: :de)
+```
+
+### translated(*attributes, locale: nil)
+
+Find records with translations in specified locale:
+
+```ruby
+Article.translated(:title)
+Article.translated(:title, locale: :de)
+Article.translated(:title, :description, locale: :de)
+```
+
+### untranslated(*attributes, locale: nil)
+
+Find records missing translations:
+
+```ruby
+Article.untranslated(:title)
+Article.untranslated(:title, locale: :de)
+```
+
+## Chaining with ActiveRecord
+
+All methods return `ActiveRecord::Relation`, so they chain naturally with AR methods:
+
+```ruby
+Article.international(title: "Hello World")
+       .where(published: true)
+       .order(created_at: :desc)
+       .limit(10)
+       .includes(:author)
+```
+
+## Combining Multiple Queries
+
+Use `merge` to combine multiple international queries:
+
+```ruby
+# Search + filter + order
+Article.international_search(title: "hello")
+       .merge(Article.international(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))
+```
+
+## Examples
+
+```ruby
+# Find published articles with German title containing "Welt"
+Article.international_search(title: "Welt", locale: :de)
+       .where(published: true)
+       .merge(Article.international_order(:title, locale: :de))
+       .limit(10)
+
+# Find articles missing German translation
+Article.untranslated(:title, locale: :de).count
+
+# Complex multi-locale query - find articles with both EN and DE titles
+Article.translated(:title, locale: :en)
+       .merge(Article.translated(:title, locale: :de))
+
+# Exclude drafts and order by title
+Article.international_not(status: "draft")
+       .merge(Article.international_order(:title))
+```

data/lib/internationalize/model.rb

@@ -28,7 +28,6 @@ module Internationalize
       #
       # When called with Symbol arguments, declares attributes as internationalized:
       #   international :title, :description
-      #   international :title, fallback: false
       #
       # When called with keyword arguments, queries translated attributes:
       #   Article.international(title: "Hello")                      # exact match
@@ -37,16 +36,15 @@ module Internationalize
       #   Article.international(title: "Hello", match: :partial, case_sensitive: true)
       #
       # @param attributes [Array<Symbol>] attributes to declare as internationalized
-      # @param fallback [Boolean] whether to fallback to default locale (default: true)
       # @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
       #
-      def international(*attributes, fallback: true, locale: nil, match: :exact, case_sensitive: false, **conditions)
+      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, fallback: fallback)
+          declare_international_attributes(attributes)
         else
           # Query mode: Article.international(title: "Hello")
           international_query(conditions, locale: locale, match: match, case_sensitive: case_sensitive)
@@ -71,7 +69,7 @@ module Internationalize
             "Use standard ActiveRecord methods for non-translated attributes."
         end
 
-        locale ||= Internationalize.locale
+        locale ||= I18n.locale
         direction = direction.to_s.upcase
         direction = "ASC" unless VALID_DIRECTIONS.include?(direction)
 
@@ -91,7 +89,7 @@ module Internationalize
       #   Article.translated(:title, :description, locale: :de)
       #
       def translated(*attributes, locale: nil)
-        locale ||= Internationalize.locale
+        locale ||= I18n.locale
         adapter = Adapters.resolve(connection)
         scope = all
 
@@ -117,7 +115,7 @@ module Internationalize
       #   Article.untranslated(:title, locale: :de)
       #
       def untranslated(*attributes, locale: nil)
-        locale ||= Internationalize.locale
+        locale ||= I18n.locale
         adapter = Adapters.resolve(connection)
         scope = all
 
@@ -143,7 +141,7 @@ module Internationalize
       #   Article.international_not(title: "Entwurf", locale: :de)
       #
       def international_not(locale: nil, **conditions)
-        locale ||= Internationalize.locale
+        locale ||= I18n.locale
         adapter = Adapters.resolve(connection)
         scope = all
 
@@ -233,12 +231,12 @@ module Internationalize
       end
 
       # Declares attributes as internationalized
-      def declare_international_attributes(attributes, fallback:)
+      def declare_international_attributes(attributes)
         self.international_attributes = international_attributes | attributes.map(&:to_sym)
 
         attributes.each do |attr|
           warn_if_missing_default(attr)
-          define_translation_accessors(attr, fallback: fallback)
+          define_translation_accessors(attr)
           define_locale_accessors(attr)
         end
       end
@@ -258,7 +256,7 @@ module Internationalize
 
       # Query translated attributes with exact or partial matching
       def international_query(conditions, locale:, match:, case_sensitive:)
-        locale ||= Internationalize.locale
+        locale ||= I18n.locale
         adapter = Adapters.resolve(connection)
         scope = all
 
@@ -288,20 +286,19 @@ module Internationalize
       end
 
       # Defines the main getter/setter for an attribute
-      def define_translation_accessors(attr, fallback:)
+      def define_translation_accessors(attr)
         translations_column = "#{attr}_translations"
 
-        # Main getter - returns translation for current locale
-        # Cache default locale at definition time for faster fallback
-        default_locale_str = fallback ? Internationalize.default_locale.to_s : nil
+        # Main getter - returns translation for current locale with fallback to default locale
+        default_locale_str = I18n.default_locale.to_s
 
         define_method(attr) do |locale = nil|
           locale_str = (locale || I18n.locale).to_s
           translations = read_attribute(translations_column)
           value = translations[locale_str]
 
-          # Short-circuit: return early if value exists or no fallback needed
-          return value if !fallback || !value.nil? || locale_str == default_locale_str
+          # Short-circuit: return early if value exists or already querying default locale
+          return value if !value.nil? || locale_str == default_locale_str
 
           translations[default_locale_str]
         end
@@ -362,23 +359,10 @@ module Internationalize
 
     # Instance methods
 
-    # Set translation for a specific locale
-    def set_translation(attr, locale, value)
-      column = "#{attr}_translations"
-      translations = read_attribute(column)
-      translations[locale.to_s] = value
-      write_attribute(column, translations)
-    end
-
-    # Get translation for a specific locale without fallback
-    def translation_for(attr, locale)
-      translations = read_attribute("#{attr}_translations")
-      translations[locale.to_s]
-    end
-
     # Check if a translation exists for a specific locale
     def translated?(attr, locale)
-      translation_for(attr, locale).present?
+      translations = read_attribute("#{attr}_translations")
+      translations[locale.to_s].present?
     end
 
     # Returns all locales that have a translation for an attribute

data/lib/internationalize/rich_text.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Internationalize
+  # Adds internationalization support for ActionText rich text attributes
+  #
+  # @example
+  #   class Article < ApplicationRecord
+  #     include Internationalize::Model
+  #     include Internationalize::RichText
+  #     international_rich_text :content
+  #   end
+  #
+  #   article.content = "<p>Hello</p>"  # Sets for current locale
+  #   article.content                    # Gets for current locale (with fallback)
+  #   article.content_de                 # Direct access to German content
+  #
+  module RichText
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Declares a rich text attribute as internationalized
+      #
+      # Creates a has_rich_text association for each available locale and
+      # provides locale-aware accessors.
+      #
+      # @param name [Symbol] the attribute name
+      #
+      def international_rich_text(name)
+        # Generate has_rich_text for each locale
+        Internationalize.locales.each do |locale|
+          rich_text_name = :"#{name}_#{locale}"
+          has_rich_text(rich_text_name)
+        end
+
+        default_locale_str = I18n.default_locale.to_s
+
+        # Main getter - returns rich text for current locale with fallback to default locale
+        define_method(name) do
+          locale_str = I18n.locale.to_s
+          rich_text = send(:"#{name}_#{locale_str}")
+
+          if rich_text.blank? && locale_str != default_locale_str
+            send(:"#{name}_#{default_locale_str}")
+          else
+            rich_text
+          end
+        end
+
+        # Main setter - sets rich text for current locale
+        define_method(:"#{name}=") do |value|
+          send(:"#{name}_#{I18n.locale}=", value)
+        end
+
+        # Predicate method
+        define_method(:"#{name}?") do
+          send(name).present?
+        end
+
+        # Check if translation exists for a specific locale
+        define_method(:"#{name}_translated?") do |locale|
+          send(:"#{name}_#{locale}").present?
+        end
+
+        # Get all locales that have this rich text
+        define_method(:"#{name}_translated_locales") do
+          Internationalize.locales.select do |locale|
+            send(:"#{name}_#{locale}").present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/internationalize/version.rb

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

data/lib/internationalize.rb

@@ -10,22 +10,12 @@ require_relative "internationalize/model"
 module Internationalize
   class << self
     # Configuration
-    attr_accessor :fallback_locale, :available_locales
+    attr_accessor :available_locales
 
     def configure
       yield self
     end
 
-    # Returns the current locale, defaulting to I18n.locale
-    def locale
-      I18n.locale
-    end
-
-    # Returns the default locale for fallbacks
-    def default_locale
-      fallback_locale || I18n.default_locale
-    end
-
     # Returns available locales, defaulting to I18n.available_locales
     def locales
       available_locales || I18n.available_locales

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: internationalize
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Sampo Kuokkanen
@@ -49,6 +49,11 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- context/configuration.md
+- context/getting-started.md
+- context/index.yaml
+- context/model-api.md
+- context/query-api.md
 - lib/generators/internationalize/translation/templates/add_translations_migration.rb.erb
 - lib/generators/internationalize/translation_generator.rb
 - lib/internationalize.rb
@@ -58,6 +63,7 @@ files:
 - lib/internationalize/adapters/postgresql.rb
 - lib/internationalize/adapters/sqlite.rb
 - lib/internationalize/model.rb
+- lib/internationalize/rich_text.rb
 - lib/internationalize/version.rb
 homepage: https://github.com/sampokuokkanen/internationalize
 licenses: