active_translation 0.7.3 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95d3e129763f16bedcfba3e7fdc8b2571650f1492609d78649f84789f1e85580
-  data.tar.gz: 2a46a6f9ab2f2fd145791db066954d705095357a854a98db0801dd3c4ffaab85
+  metadata.gz: 41efab1065efc26a1d0e04a05ec1be8f0f4b5a9143b0d486c958540f8cb970bc
+  data.tar.gz: 02b939cc57e481288dd6d691f65c86cb6bacac2eface6866fa3f8f2f91765dda
 SHA512:
-  metadata.gz: ca396a230135fb092c5dfe8e3aa43dcef5efd734de459cce75d8da8b9e2783642f4d713c756dbd528873e5b2e48bd9109114c5ff4dcb2a12188d01ce0d3aca14
-  data.tar.gz: ceb3e4c83ef21ac1edbc03591ba07accb98e5aa1cb75f58f154d0cd674060d5650876f3d01b3d62cebf2f2a21fe2f760627048b8cfdbc42edfd44e7ca41af9bd
+  metadata.gz: 5b816b22734257d8818fe47035c50793afaf5801de186da7922479803051181d5e58c3859ac2123d916593431c412b0fae9acd24d049aee4534e6cc9b164c576
+  data.tar.gz: a440a16da19267c58e99ae3f017139465aa2ddec3b6418ce9b61ef023778221c71460932e28631638f30ee2fa3b2519603806f06beabcb58ed4099f354506951

data/README.md

@@ -33,7 +33,7 @@ Instead, what if you just add a single line to your `Category` model. Now produc
 Add the gem to your gemfile:
 
 ```ruby
-gem "active_translation", git: "https://github.com/seanhogge/active_translation"
+gem "active_translation"
 ```
 
 And then bundle:
@@ -108,8 +108,6 @@ or
 translates :content, into: -> { I18n.available_locales - [ I18n.default_locale ] }
 ```
 
-> `it` is a recent Ruby syntactical grain of sugar. It's the same as `_1` which lets you skip the `{ |arg| arg == :stuff }` repetition
-
 #### Into All
 
 Because translating a model into all the locales your app may define is so common, you can pass `:all` to the `into` argument to achieve the same result as passing `-> { I18n.available_locales - [ I18n.default_locale ] }`.
@@ -168,6 +166,28 @@ Manual attributes have a special setter in the form of `#{locale}_#{attribute_na
 
 These attributes never trigger retranslation, and are never checked against the original text - it's entirely up to you to maintain them. However, it does get stored alongside all the other translations, keeping your database tidy and your translation code consistent.
 
+### Caching
+
+You may have a model where many records share the same translated content. For instance a table of jobs might have thousands or millions of "housekeeper" jobs, all with the title "Housekeeper" or "Houseperson". It would be foolish and expensive to make a call to translate these repeatedly.
+
+Thus, you can add the `cache` directive. You can set it to `true`, to a `String` or `Symbol`, or to an `Array`
+
+If `true`, then all calls to translate that model will be cached. So if you have Job ID 1 with a title of "Sales Manager" and you translate it, Active Translation will reach out and get a translation for all the locales for "Sales Manager".
+
+If you have Job ID 2 with the same "Sales Manager" title, translating it will result in no call being made for the title - it's already stored in the Active Translation cache.
+
+If you have a different model, like a `JobTemplate` that has an attribute called `template_title` and no caching enabled, translating that `JobTemplate` will **still** use the cache. The overhead of this indexed database lookup is worth the savings.
+
+So you can't control when Active Translation looks for a cached value, but you can control what gets entered into the cache.
+
+When `cache: true` is set, all translatable attributes will be cached.
+
+When `cache: :subhead` is set, only the `subhead` attribute translations will be cached.
+
+When `cache: [ :name, :heading ]` is set, only the `name` and `heading` translations will be cached.
+
+So don't cache attributes that are huge or unlikely to ever be duplicated. For instance, do not cache an attribute that holds HTML content, or probably anything that's a TEXT column in the database. Unless, of course, those large text columns actually are frequently duplicated. Use your ~~brain~~ discretion.
+
 ### The Show
 
 Once you have added the `translates` directive with your columns, locales, and constraints and your models have been translated to at least one locale, it's time to actually use them.
@@ -338,9 +358,9 @@ You can call `translation_config` on a model or instance to see what you've set
 
 ActiveTranslation doesn't check the accuracy of translations in any way. It assumes that the response from Google is always perfect. If you are translating sensitive content where accuracy is critical in a legal or existential sense, you must handle translation auditing separately.
 
-So if you use the for an EULA, make it a manual attribute or don't use ActiveTranslation for it at all.
+So if you use Active Translation for a column that contains legal language like an end-user license agreement (EULA), make it a manual attribute or don't use ActiveTranslation for it at all.
 
-ActiveTranslation doesn't redact any content. It assumes you would never send PII or financial data for translation. So... please don't.
+ActiveTranslation doesn't redact any content. It assumes you would never send PII or financial data for translation. So please don't.
 
 
 ## Testing

data/app/models/active_translation/cache.rb

@@ -0,0 +1,8 @@
+module ActiveTranslation
+  class Cache < ApplicationRecord
+    self.table_name = :active_translation_cache
+
+    validates :locale, presence: true
+    validates :checksum, presence: true
+  end
+end

data/lib/active_translation/translatable.rb

@@ -3,13 +3,14 @@ module ActiveTranslation
     extend ActiveSupport::Concern
 
     class_methods do
-      def translates(*attributes, manual: [], into:, unless: nil, if: nil)
+      def translates(*attributes, manual: [], into:, unless: nil, if: nil, cache: false)
         @translation_config ||= {}
         @translation_config[:attributes] = Array(attributes).map(&:to_s)
         @translation_config[:manual_attributes] = Array(manual).map(&:to_s)
         @translation_config[:locales] = into
         @translation_config[:unless] = binding.local_variable_get(:unless)
         @translation_config[:if] = binding.local_variable_get(:if)
+        @translation_config[:cache] = cache
 
         has_many :translations, class_name: "ActiveTranslation::Translation", as: :translatable, dependent: :destroy
 
@@ -23,16 +24,19 @@ module ActiveTranslation
         # Respond to calls such as fr_translation or de_translation
         # Respond to calls such as model.name(locale: :fr)
         define_method(:method_missing) do |method_name, *args, &block|
-          super() unless method_name.to_s.split("_").size == 2
+          # if the method name doesn't have an underscore with at least 1 character on both sides
+          super(method_name, *args, &block) unless method_name.to_s.split("_", 2).reject(&:blank?).size == 2
 
           locale = method_name.to_s.split("_").first
           attribute = method_name.to_s.split("_").last
 
+          # if something like "model.fr_title" is being called (no =)
           if translation_config[:manual_attributes].include? attribute
             translation = translations.find_by(locale: locale)
             return read_attribute(attribute) unless translation
 
             translation.translated_attributes[attribute].presence || read_attribute(attribute)
+          # if something like "model.fr_title = 'Zut alors' is being called"
           elsif attribute.last == "=" && translation_config[:manual_attributes].include?(attribute.delete("="))
             attribute.delete!("=")
             translation = translations.find_or_initialize_by(locale: locale.to_s)
@@ -40,8 +44,12 @@ module ActiveTranslation
             attrs[attribute] = args.first
             translation.translated_attributes = attrs
             translation.save!
+          # if something like "model.fr_translation" is being called
           elsif attribute == "translation" || translation_config[:attributes].include?(attribute)
             translations.find_by(locale: locale)
+          # if some method with an underscore that doesn't match anything above
+          else
+            super(method_name, *args, &block)
           end
         end
 
@@ -150,6 +158,52 @@ module ActiveTranslation
       end
     end
 
+    def translate_attribute(attribute, locale)
+      return nil if send(attribute).nil?
+
+      cached_translation = ActiveTranslation::Cache.find_by(
+        checksum: text_checksum(send(attribute)),
+        locale: locale,
+      )
+
+      translated_text = if Rails.env.test?
+        cached_translation&.translated_text || "[#{locale}] #{send(attribute)}"
+      else
+        cached_translation&.translated_text || ActiveTranslation::GoogleTranslate.translate(target_language_code: locale, text: text)
+      end
+
+      case translation_config[:cache]
+      when TrueClass
+        ActiveTranslation::Cache.find_or_create_by(
+          checksum: text_checksum(send(attribute)),
+          locale:,
+        ).update(translated_text:,)
+      when String, Symbol
+        return unless attribute.to_s == translation_config[:cache].to_s
+
+        ActiveTranslation::Cache.find_or_create_by(
+          checksum: text_checksum(send(attribute)),
+          locale:,
+        ).update(translated_text:,)
+      when Array
+        return unless translation_config[:cache].map(&:to_s).include? attribute.to_s
+
+        ActiveTranslation::Cache.find_or_create_by(
+          checksum: text_checksum(send(attribute)),
+          locale:,
+        ).update(translated_text:,)
+      end
+
+      translated_text
+    end
+
+    def translation_cached?(attribute, locale)
+      ActiveTranslation::Cache.find_by(
+        checksum: text_checksum(send(attribute)),
+        locale:,
+      )
+    end
+
     def translation_checksum
       values = translatable_attribute_names.map { |attr| read_attribute(attr).to_s }
       Digest::MD5.hexdigest(values.join)
@@ -216,6 +270,10 @@ module ActiveTranslation
       evaluate_condition(translation_config[:if])
     end
 
+    def text_checksum(text)
+      Digest::MD5.hexdigest(text)
+    end
+
     def translatable_attributes_changed?
       saved_changes.any? && saved_changes.keys.intersect?(translatable_attribute_names)
     end

data/lib/active_translation/translation_job.rb

@@ -6,8 +6,7 @@ module ActiveTranslation
       translated_data = {}
 
       object.translatable_attribute_names.each do |attribute|
-        source_text = object.read_attribute(attribute)
-        translated_data[attribute.to_s] = translate_text(source_text, locale)
+        translated_data[attribute.to_s] = object.translate_attribute(attribute, locale)
       end
 
       translation = object.translations
@@ -24,13 +23,5 @@ module ActiveTranslation
         source_checksum: checksum
       )
     end
-
-    private
-
-    def translate_text(text, target_locale)
-      return "[#{target_locale}] #{text}" if Rails.env.test?
-
-      ActiveTranslation::GoogleTranslate.translate(target_language_code: target_locale, text: text)
-    end
   end
 end

data/lib/active_translation/version.rb

@@ -1,3 +1,3 @@
 module ActiveTranslation
-  VERSION = "0.7.3"
+  VERSION = "0.7.5"
 end

data/lib/generators/active_translation/templates/create_translations.rb

@@ -10,5 +10,13 @@ class CreateTranslations < ActiveRecord::Migration[7.0]
 
     add_index :active_translation_translations, [ :translatable_type, :translatable_id, :locale ],
       unique: true, name: "index_translations_on_translatable_and_locale"
+
+    create_table :active_translation_cache do |t|
+      t.string :locale, null: false
+      t.string :checksum
+      t.text :translated_text
+    end
+
+    add_index :active_translation_cache, [ :checksum, :locale ], unique: true
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_translation
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.5
 platform: ruby
 authors:
 - Talentronic
@@ -106,6 +106,7 @@ files:
 - app/lib/active_translation/google_translate.rb
 - app/mailers/active_translation/application_mailer.rb
 - app/models/active_translation/application_record.rb
+- app/models/active_translation/cache.rb
 - app/models/active_translation/translation.rb
 - app/views/layouts/active_translation/application.html.erb
 - config/routes.rb