mongo_translatable 0.1.0

data/app/views/translations/new.html.erb

@@ -0,0 +1,7 @@
+<% @button_text = t("translations.new.create") -%>
+
+<% form_for(@translation) do |f| %>
+
+<%= render :partial => f -%>
+
+<% end %>

data/app/views/translations/show.html.erb

@@ -0,0 +1,12 @@
+<ul>
+<% translated_values_with_localized_labels.each do |translatable_value| %>
+  <li><%= translatable_value[:localized_label] %>
+    <% if translatable_value[:value] -%>
+      <ul><li><%= translatable_value[:value] -%></li></ul>
+    <% end %>
+  </li>
+  <% end %>
+</ul>
+
+<%= link_to(t('translations.show.edit'), { :id => h(@translation.locale), :action => :edit }) %> |
+<%= link_to(t('translations.show.translations'), { :action => :index }) %>

data/config/locales/en.yml

@@ -0,0 +1,33 @@
+en:
+  translations:
+    new:
+      create: "Create"
+    edit:
+      update: "Update"
+    form:
+      locale: "Choose language"
+      original_has_no_value: "This field cannot be translated, as the original does not have a value for it."
+      translate_from_and_to: "Translate from {{from}} to {{to}}"
+    helpers:
+      translate: "Translate"
+      are_you_sure: 'Are you sure?'
+      available_in: "Available in:"
+      close_box: "[close]"
+      delete: "delete"
+      edit: "edit"
+      manage: "manage"
+      needs_translating_to: "Needs translating to:"
+    index:
+      are_you_sure: 'Are you sure?'
+      back: "Return to {{type}}"
+      delete: "Delete"
+      edit: "Edit"
+      new: "New Translation"
+      title: "Translations for this {{type}}"
+    show:
+      edit: "Edit"
+      translations: "Translations"
+    controllers:
+      created: 'Translation was successfully created.'
+      deleted: 'Translation was successfully deleted.'
+      updated: 'Translation was successfully updated.'

data/config/locales/fr.yml

@@ -0,0 +1,18 @@
+fr:
+  translations:
+    new:
+      create: "Créer"
+    edit:
+      update: "Mettre à jour"
+    form:
+      locale: "Choisissez la langue"
+      translate_from_and_to: "Traduire de l' {{from}} à {{to}}"
+    helpers:
+      available_in: "Disponible en:"
+      close_box: "[Fermer]"
+      needs_translating_to: "Les besoins de traduction à:"
+    index:
+      new: "Translate"
+    show:
+      edit: "Éditer"
+      translations: "Traductions"

data/lib/mongo_translatable.rb

@@ -0,0 +1,336 @@
+# -*- coding: utf-8 -*-
+require "active_record"
+require "mongo_mapper"
+
+ActionController::Base.send(:include, TranslationsControllerHelpers)
+ActionController::Base.send(:helper, TranslatablesHelper)
+
+# load our locales
+I18n.load_path += Dir[ File.join(File.dirname(__FILE__), '..', 'config', 'locales', '*.{rb,yml}') ]
+
+module MongoTranslatable #:nodoc:
+  # MongoTranslatable is for taking advantage of MongoDB for storing translations
+  # of ActiveRecord models. Here is how it works in practice:
+  #   class Item < ActiveRecord::Base
+  #     mongo_translate :label
+  #   end
+  #
+  #   I18n.locale = :en
+  #
+  #   item = Item.create(:label => "a label")
+  #   p item.locale
+  #   "en"
+  #
+  #   item = Item.find(1)
+  #   p item.label
+  #   "a label"
+  #
+  #   item.translate(:label => "etiketissä", :locale => :fi).save
+  ## or you could have set I18n.locale = :fi in calling env and dropped locale from args
+  #
+  #   I18n.locale = :fi
+  #   item = Item.find(1)
+  #   p item.label
+  #   "etiketissä"
+  #   p item.locale
+  #   "fi"
+  #
+  # If
+  # The general approach is inspired by this code in globalize2:
+  # http://github.com/joshmh/globalize2/blob/master/lib/globalize/active_record.rb
+  # grab what the normal finder would return
+  # and look up corresponding translated version of the objects in question
+  # swap in corresponding translated attributes of object
+  # creates TranslatableClass::Translation when the declaration method is defined
+  # ala acts_as_versioned VersionedClass::Version
+  # every translatable class gets their own Translation class under it
+  #
+  # TODO: translations aren't real associations
+  # and the translations method is thus not chainable as you would expect
+  # currently investigating adding a plugin for mongo_mapper that will do associations declaired
+  # from activerecord models
+  # in the meantime, you will like want to use the "translation_for(locale)" method
+  module Translated
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def mongo_translate(*args)
+        # don't allow multiple calls
+        return if self.included_modules.include?(MongoTranslatable::Translated::InstanceMethods)
+
+        send :include, MongoTranslatable::Translated::InstanceMethods
+
+        options = args.last.is_a?(Hash) ? args.pop : Hash.new
+        redefine_find = !options[:redefine_find].nil? ? options[:redefine_find] : true
+
+        translatable_attributes = args.is_a?(Array) ? args : [args]
+
+        cattr_accessor :translatable_attributes, :as_foreign_key_sym
+
+        # expects a single attribute name symbol or array of attribute names as symbols
+        self.translatable_attributes = translatable_attributes
+        self.as_foreign_key_sym = self.name.foreign_key.to_sym
+
+        before_save :set_locale_if_necessary
+        before_destroy :destroy_translations
+
+        # create the dynamic translation model
+        const_set("Translation", Class.new).class_eval do
+          include MongoMapper::Document
+
+          cattr_accessor :translatable_class
+          self.translatable_class = self.name.split('::').first.constantize
+
+          def self.declare_key_from(spec)
+            key_type = String
+            key_name = spec
+
+            key_name, key_type = spec if spec.is_a?(Array)
+
+            unless keys.include?(key_name.to_s)
+              class_eval do
+                key key_name, key_type
+              end
+            end
+          end
+
+          self.translatable_class.translatable_attributes.each { |a| declare_key_from(a) }
+
+          key :locale, String, :required => true
+
+          before_save :locale_to_string
+
+          # for classes that have dynamic translatable_attributes
+          # add definition of keys for mongo_translatable Translation class, if not already defined
+          # add accessor methods, too, if not already defined
+          def self.update_keys_if_necessary_with(new_translatable_attributes)
+            attribute_type = String
+
+            new_translatable_attributes.each { |a| declare_key_from(a) }
+          end
+
+          # TODO: add validation for locale unique to translatable_class.as_foreign_key_sym scope
+          # not implemented in mongo mapper yet
+
+          def translatable
+            self.translatable_class.find(self.send(self.translatable_class.as_foreign_key_sym))
+          end
+
+          protected
+          # always store string version of locale (rather than symbol)
+          def locale_to_string
+            self.locale = self.locale.to_s
+          end
+        end
+
+        class_eval do
+
+          # dynamically define translation accessor methods
+          def self.define_translation_accessor_method_for(attribute_name)
+            # create the template code
+            code = Proc.new { |locale|
+              translation = translation_for(locale)
+              translation.send(attribute_name.to_sym) if translation
+            }
+
+            define_method(attribute_name.to_s + "_translation_for", &code)
+          end
+
+          # define convenience method for each translatable_attribute
+          # uses class method, see class method definitions
+          translatable_attributes.each do |attribute|
+            define_translation_accessor_method_for(attribute)
+          end
+
+          # take a collection of this class
+          # and process translations accordingly
+          def self.translatable_processing_of(results, *args)
+            # at least for now, we skip :select queries
+            # as we can't rely on having attributes available that we need
+            # to compare against
+            # we also return if results are nil
+            return results if (args.is_a?(Array) &&
+                               args.last.is_a?(Hash) &&
+                               args.last.keys.include?(:select) &&
+                               !args.last[:select].nil?) || results.nil?
+
+            # handle single record
+            if results.is_a?(self)
+              result = results
+              results = swap_in_translation_for_single(result)
+            else
+              # handle multiple records
+              results = swap_in_translation_for_multiple(results)
+            end
+          end
+
+          # does the actual swapping of translatable_attributes for a result
+          def self.swap_in_translation_for_single(result)
+            # only look up translation if the required locale is not the default for the record
+            if result.present? && result.locale != I18n.locale.to_s
+              # look up translation and swap in its attributes for result
+              translated = result.translation_for(I18n.locale)
+              if translated.present?
+                result.translatable_attributes.each do |translated_attribute|
+                  unless translated.attributes[translated_attribute].blank?
+                    result.set_translation_for_this(translated_attribute, translated.attributes[translated_attribute])
+                  end
+                end
+                result.locale = translated.locale
+              end
+            end
+
+            result
+          end
+
+          # does the actual swapping of translatable_attributes per result
+          # and returns new collection of translated results
+          def self.swap_in_translation_for_multiple(results)
+            # do second query of translations
+            # if item locale is different than current locale
+            # swap in attributse from translation for item that is current locale
+
+            # rather than rerun the full query, simply get ids and add locale
+            result_ids = results.collect(&:id)
+
+            conditions = {:locale => I18n.locale.to_s}
+            conditions[as_foreign_key_sym] = result_ids
+
+            translations = self::Translation.all(conditions)
+
+            translated_results = results
+            index = 0
+            results.each do |result|
+              unless result.locale == I18n.locale.to_s
+                matching_translation = translations.select { |t| t[as_foreign_key_sym] == result.id }.first
+
+                if matching_translation
+                  result.translatable_attributes.each do |key|
+                    unless matching_translation.attributes[key].blank?
+                      result.set_translation_for_this(key, matching_translation.attributes[key])
+                    end
+                  end
+
+                  result.locale = I18n.locale.to_s
+
+                  translated_results[index] = result
+                end
+              end
+              index += 1
+            end
+            results = translated_results
+          end
+
+        end
+
+        if redefine_find
+
+          class_eval do
+            # override find, this is called by all the dynamic finders
+            # it isn't called by find_by_sql though (may be other exceptions)
+            def self.find(*args)
+              # get the standard results from find
+              # this will throw a RecordNotFound before executing our code
+              # if that is the response
+              results = super(*args)
+
+              results = translatable_processing_of(results, *args)
+            end
+          end
+        end
+      end
+    end
+    module InstanceMethods
+      # for classes that have dynamice translatable attributes, we may need to update
+      # accessor methods for a dynamic translatable attribute
+      def update_translation_for_methods_if_necessary_with(new_translatable_attributes)
+        new_translatable_attributes.each do |attribute|
+          unless respond_to?("#{attribute.to_s}_translation_for".to_sym)
+            self.class.define_translation_accessor_method_for(attribute)
+          end
+        end
+      end
+
+      # this will replace specified attribute with its translated value
+      # taks an attribute name as a string or symbol
+      def set_translation_for_this(attribute_name, translated_value)
+        send(attribute_name.to_s + "=", translated_value)
+      end
+
+      def translations
+        self.class::Translation.all(self.class.as_foreign_key_sym => id)
+      end
+
+      # sometimes all you need is only the locales of translations
+      def translations_locales
+        self.class::Translation.all(self.class.as_foreign_key_sym => id, :select => 'locale')
+      end
+
+      # get a list of locales as syms for all translations locales, plus object's original locale
+      def available_in_these_locales
+        [original_locale] + translations_locales.collect(&:locale)
+      end
+
+      # list of locales that haven't been translated yet
+      def needed_in_these_locales
+        TranslationsHelper::available_locales.keys - available_in_these_locales
+      end
+
+      # assumes unique locale
+      def translation_for(locale)
+        self.class::Translation.first(self.class.as_foreign_key_sym => id, :locale => locale)
+      end
+
+      # this will create a new translation (but won't save it)
+      # with either passed in options
+      # note that we don't save the changes to self
+      # only the new translation
+      # will return nothing if translate to locale
+      # is the same as the object to translate's original locale
+      def translate(options = {})
+        translation_locale = options[:locale] || I18n.locale
+
+        @translation = self.class::Translation.new({
+          :locale => translation_locale,
+          :translatable_locale => self.locale, # save original locale
+          self.class.as_foreign_key_sym => id
+        })
+
+        if translation_locale.to_s == original_locale.to_s
+          # TODO: locale's emptiness is the reported error
+          # when this is triggered, figure out why
+          # serving its purpose though to prevent a translation to be added for original_locale
+          @translation.errors.replace(:locale, "Cannot add translation the same as the original locale.")
+        else
+          # work through self and replace attributes
+          # with the passed in translations for defined translatable_attributes
+          translatable_attributes.each do |translated_attribute|
+            translated_value = options[translated_attribute]
+            @translation.send("#{translated_attribute.to_sym}=", translated_value) if translated_value.present?
+          end
+        end
+
+        @translation
+      end
+
+      protected
+      # always store string version of locale (rather than symbol)
+      # if none is specified, use environment's setting
+      def set_locale_if_necessary
+        self.locale = self.locale.present? ? self.locale : I18n.locale
+        self.locale = self.locale.to_s
+        self.original_locale = self.locale
+      end
+
+      def destroy_translations
+        translations = self.class::Translation.all(self.class.as_foreign_key_sym => id)
+        translations.each { |translation| translation.destroy }
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval { include MongoTranslatable::Translated }

data/lib/mongo_translatable_configuration.rb

@@ -0,0 +1,5 @@
+class MongoTranslatableConfiguration
+  @@provide_autotranslate = false
+
+  cattr_accessor :provide_autotranslate
+end

data/lib/translatables_helper.rb

@@ -0,0 +1,227 @@
+module TranslatablesHelper
+  def available_in_locales_for(translatable, options = {})
+    return if TranslationsHelper.available_locales.size < 2
+
+    html = "<ul style='list-style:none; margin:0; padding:0;'>"
+    html += "<li style='float:left;'>#{I18n.t('translations.helpers.available_in')}</li>"
+    options[:params] ||= {}
+
+    translated_in_locales = Array.new
+    translatable.available_in_these_locales.each_with_index do |locale, index|
+      styles = "float: left; padding: 0 5px; #{'border-left: 1px solid #000' unless index == 0}"
+      onclick = 'update_translation_box(this); return false' if options[:lightbox]
+
+      html += content_tag(:li, :style => styles) do
+        link_to_unless_current(TranslationsHelper::available_locales[locale],
+          url_for(:locale => locale, :to_locale => (params[:to_locale] if defined?(params))),
+          { :onclick => onclick })
+      end
+      translated_in_locales << locale unless locale == translatable.original_locale
+    end
+
+    manage_links = manage_translations_links_for(translatable, translated_in_locales, options)
+
+    if translated_in_locales.size > 0
+      html += "<li style='float:left; padding-left: 25px;'>(#{manage_links})</li>"
+    end
+
+    html += '</ul>'
+    html += "<div style='clear:both;'></div>"
+
+    translatable_lightbox_js_and_css if options[:lightbox]
+    google_auto_translatable_js
+
+    html
+  end
+
+  def manage_translations_links_for(translatable, translated_in_locales, options)
+    manage_links = String.new
+
+    # we only have one locale beyond the original locale
+    # just give its edit and delete links
+    if translated_in_locales.size == 1
+      manage_links = link_to(I18n.t('translations.helpers.edit'), {
+                               :controller => :translations,
+                               :action => :edit,
+                               :id => translated_in_locales.first,
+                               translatable_key_from(translatable) => translatable
+                             }.merge(options[:params]))
+      manage_links += " | " + link_to(I18n.t('translations.helpers.delete'), {
+                                        :controller => :translations,
+                                        :action => :destroy,
+                                        :id => translated_in_locales.first,
+                                        :return_to_translated => true,
+                                         translatable_key_from(translatable) => translatable
+                                       }.merge(options[:params]), {
+                                        :method => :delete,
+                                        :confirm => t('translations.helpers.are_you_sure') })
+    elsif translated_in_locales.size > 1
+      manage_links = link_to(I18n.t('translations.helpers.manage'), {
+                               :controller => :translations,
+                               :action => :index,
+                               translatable_key_from(translatable) => translatable
+                             })
+    end
+  end
+
+  def needed_in_locales_for(translatable, options = {})
+    return if TranslationsHelper.available_locales.size < 2
+
+    html = "<ul style='list-style:none; margin:0; padding:0;'>"
+    html += "<li style='float:left;'>#{I18n.t('translations.helpers.needs_translating_to')}</li>"
+
+    needed_locales_links = needed_in_locales_links(translatable, options)
+    return if needed_locales_links.blank?
+
+    needed_locales_links.each_with_index do |link, index|
+      styles = "float: left; padding: 0 10px; #{'border-left: 1px solid #000' unless index == 0}"
+      html += content_tag(:li, :style => styles) do
+        link
+      end
+    end
+
+    html += '</ul>'
+    html += "<div style='clear:both;'></div>"
+
+    translatable_lightbox_js_and_css if options[:lightbox]
+    google_auto_translatable_js
+
+    html
+  end
+
+  def needed_in_locales_links(translatable, options = {})
+    return if TranslationsHelper.available_locales.size < 2
+    needed_locales = translatable.needed_in_these_locales
+    return unless needed_locales.any?
+    options[:params] ||= {}
+    links = needed_locales.collect do |locale|
+      onclick = 'update_translation_box(this); return false' if options[:lightbox]
+      link_to(TranslationsHelper::available_locales[locale],
+              { :action => :new,
+                :controller => :translations,
+                translatable_key_from(translatable) => translatable,
+                :to_locale => locale }.merge(options[:params]), { :onclick => onclick })
+    end
+    links
+  end
+
+
+  #Links to all locales
+  def raw_locale_links(options = {})
+     links = TranslationsHelper::available_locales.keys.collect do |locale|
+       {:link => link_to_unless_current(TranslationsHelper::available_locales[locale],
+          url_for(:locale => locale, :to_locale => (params[:to_locale] if defined?(params)))
+        ), :locale => locale}
+     end
+     links
+  end
+
+  def raw_available_in_locales_links(translatable, options = {})
+    onclick = 'update_translation_box(this); return false' if options[:lightbox]
+    links = translatable.available_in_these_locales.collect do |locale|
+      if locale == I18n.locale
+        { :link => TranslationsHelper::available_locales[locale],
+          :locale => locale }
+      else
+        { :link => link_to(TranslationsHelper::available_locales[locale],
+                           url_for(:locale => locale,
+                                   :to_locale => (params[:to_locale] if defined?(params))),
+                           { :onclick => onclick }),
+          :locale => locale }
+      end
+    end
+    links
+  end
+
+  #Translate link for the given locale
+  def translate_link(translatable, options = {})
+    options[:params] ||= {}
+    options[:onclick] = 'update_translation_box(this); return false' if options[:lightbox]
+    options[:onclick] ||= ""
+    
+    action = translatable.translation_for(params[:locale]) ? :edit : :new
+    action = options[:action].present? ? options[:action] : action
+
+    options[:params][:id] = params[:locale] if action == :edit
+    link_to(I18n.t('translations.helpers.translate'),
+            { :action => action,
+              :controller => :translations,
+              translatable_key_from(translatable) => translatable,
+              :to_locale => params[:locale] }.merge(options[:params]), :onclick => options[:onclick])
+  end
+
+  def translatable_key_from(translatable)
+    translatable.class.name.tableize.singularize + '_id'
+  end
+
+  def translatable_lightbox_js_and_css
+    return if @translatable_lightbox_js_and_css_inserted
+
+    js = javascript_tag("
+    function close_open_translation_box() {
+      if ($('translate_outer_box')) { $('translate_outer_box').remove(); }
+      if ($('translate_inner_box')) { $('translate_inner_box').remove(); }
+    }
+
+    function page_dimensions() {
+      var html_dimensions = $$('html').first().getDimensions();
+      var body_dimensions = document.body.getDimensions();
+
+      var dimensions = new Array();
+      dimensions['width'] = (html_dimensions['width'] > body_dimensions['width'] ? html_dimensions['width'] : body_dimensions['width']);
+      dimensions['height'] = (html_dimensions['height'] > body_dimensions['height'] ? html_dimensions['height'] : body_dimensions['height']);
+      return dimensions;
+    }
+
+    function update_translation_box(element) {
+      new Ajax.Request(element.href, {
+        method: 'get',
+        onComplete: function(transport) {
+          var outer_box = new Element('div', { 'id': 'translate_outer_box' }).setOpacity(0.8).setStyle({ width: page_dimensions()['width'] + 'px', height: page_dimensions()['height'] + 'px' });
+          var close_link = '<a href=\\'\\' name=\\'top\\' title=\\'Close\\' onclick=\\'close_open_translation_box(); return false;\\'>#{I18n.t('translations.helpers.close_box')}</a>';
+          var close_box = '<div id=\\'translate_close_box\\'>' + close_link + '</div>';
+          var inner_box = new Element('div', { 'id': 'translate_inner_box' }).update(close_box + transport.responseText);
+          close_open_translation_box();
+          document.body.appendChild(outer_box);
+          document.body.appendChild(inner_box);
+          window.location.hash = 'top'; // send us to the top of the translation box
+          window.onresize = function() {
+            $('translate_outer_box').setStyle({ width: page_dimensions()['width'] + 'px', height: page_dimensions()['height'] + 'px' });
+          }
+        }
+      });
+    }
+    ")
+
+    css = content_tag("style", :type => "text/css") do
+      <<-CSS
+      #translate_outer_box { position: absolute; top: 0; left: 0; width: 100%; min-height: 500px; background-color: #000; }
+      #translate_inner_box { position: absolute; top: 0; left: 15%; right: 15%; margin: 50px auto; padding: 20px;
+                             background-color: #fff; -moz-border-radius: 1em; -webkit-border-radius: 1em; }
+      #translate_close_box { float: right; margin-top: -45px; margin-right: -15px; }
+      #translate_close_box a { color: #fff; }
+      CSS
+    end
+
+    @translatable_lightbox_js_and_css_inserted = true
+    content_for(:add_on_scripts_and_links) { js + css }
+  end
+
+  def google_auto_translatable_js
+    return unless MongoTranslatableConfiguration.provide_autotranslate
+    return if @google_auto_translatable_js_inserted
+
+    js = javascript_include_tag("http://www.google.com/jsapi?format=")
+    js += javascript_tag("
+    google.load('language', '1');
+    function getGoogleTranslation(field_id, text, from_language, to_language) {
+      google.language.translate(text, from_language, to_language, function(result) {
+        if (!result.error) { Form.Element.setValue(field_id, result.translation); }
+      });
+    }
+    ")
+
+    @google_auto_translatable_js_inserted = true
+    content_for(:add_on_scripts_and_links) { js }
+  end
+end