kete_translatable_content 0.1.0

data/generators/kete_translatable_content_tests/templates/kete_translatable_content_translations_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+# test that the translations for each model are available (so when
+# new translatable fields are added, it doesn't have missing strings)
+class KeteTranslatableContentTranslationsTest < ActiveSupport::TestCase
+
+  Kete.translatables.each do |name, attributes|
+
+    context "The #{name.humanize} translatable" do
+
+      attributes['translatable_attributes'].each do |attr|
+
+        should "have a translation for #{attr}" do
+          assert I18n.t("#{name.pluralize}.form.#{attr}") !~ /translation missing/
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/generators/kete_translatable_content_tests/templates/kete_translations_test.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/integration_test_helper'
+
+def translate_for_locales(record, *locales)
+  locales.each do |locale|
+    visit "/en/site/#{record.class.name.pluralize.downcase}/#{record.id}/translations/new?to_locale=#{locale}"
+    click_button 'Create'
+    assert_contain 'Translation was successfully created.'
+  end
+end
+
+# simulate languages available without actually making them
+def I18n.available_locales_with_labels; { 'en' => 'English', 'fr' => 'Français', 'zh' => '中文' }; end
+TranslationsHelper.available_locales = I18n.available_locales_with_labels
+def I18n.available_locales; I18n.available_locales_with_labels.keys; end
+RoutingFilter::Locale.locales = I18n.available_locales
+
+class KeteTranslationsTest < ActionController::IntegrationTest
+
+  context "A translatable basket" do
+
+    include Webrat::HaveTagMatcher
+
+    setup do
+      add_admin_as_super_user
+      login_as('admin')
+
+      # create_new_basket is a method in Kete's integration helpers to create
+      # the basket, and remove it when tests are run (so each test has a clean
+      # environment)
+      @basket = create_new_basket :name => 'Translatable Basket'
+    end
+
+    should "have links to locales needing translation on its show page" do
+      visit "/en/#{@basket.urlified_name}/baskets/edit/#{@basket.id}"
+      assert_contain "Needs translating to"
+      assert_have_tag "a", :href => "/en/#{@basket.urlified_name}/baskets/#{@basket.id}/translations/new?to_locale=zh", :content => "中文"
+    end
+
+    context "that has been previously translated" do
+
+      setup do
+        translate_for_locales(@basket, :zh)
+      end
+
+      should "have locales that have been translated on its show page" do
+        url_stub = "#{@basket.urlified_name}/baskets/edit/#{@basket.id}"
+        visit "/en/#{url_stub}"
+        assert_have_tag "li", :content => "Français"
+        assert_have_tag "a", :href => "/zh/#{url_stub}", :content => "中文"
+      end
+
+    end
+
+  end
+
+end

data/generators/kete_translatable_content_tests/templates/mongo_factories.rb

@@ -0,0 +1,6 @@
+#Usings topic types because they are translatable and have multiple fields
+Factory.define :topic_type do |t|
+  #make the name random. should install faker, but only need this one.
+  t.sequence(:name){ |n| "name#{n}"}
+  t.description 'spam'
+end

data/generators/kete_translatable_content_tests/templates/mongo_test_helper.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + "/mongo_factories")
+
+
+LOCALE_LABELS = { :en => "a label",
+  :ar => "Ar_lable",
+  :fi => "fi_lable",
+  :fr => "fr_label",
+  :zh => "zh_label"}
+
+ALL_TRANSLATION_LOCALE_KEYS_EXCEPT_EN = LOCALE_LABELS.keys - [:en]
+
+MongoMapper.database = 'test'
+
+def translate_topic_type_for_locales(topic_type, locales)
+  create_translations_for(topic_type, [:name], locales)
+end
+
+def create_translations_for(item, attrs_to_mock = [:title], locales = nil)
+  original_locale = I18n.locale
+
+  locales ||= ALL_TRANSLATION_LOCALE_KEYS_EXCEPT_EN
+  locales = [locales] unless locales.is_a?(Array)
+  locales.each do |locale|
+    I18n.locale = locale
+    
+    attrs = Hash.new
+    attrs_to_mock.each do |attr_sym|
+      attrs[attr_sym] = LOCALE_LABELS[locale]
+    end
+
+    item.translate(attrs).save
+  end
+
+  I18n.locale = original_locale
+end
+
+

data/generators/kete_translatable_content_tests/templates/mongo_translatable_test.rb

@@ -0,0 +1,262 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+require 'mongo_test_helper'
+
+class MongodbTranslatableTest < ActiveSupport::TestCase
+  context "A translation" do
+    setup do
+      I18n.locale = I18n.default_locale
+
+      @topic_type = Factory.create(:topic_type)
+
+      topic_type_hash = Hash.new
+      topic_type_hash[:name] = @topic_type.attributes['name']
+      topic_type_hash[:locale] = :fr
+      topic_type_hash[@topic_type.class.as_foreign_key_sym] = @topic_type.id
+      @translation = @topic_type.class::Translation.create(topic_type_hash)
+    end
+
+    should "have a locale" do
+      if assert(@translation.respond_to?(:locale))
+        assert @translation.locale
+      end
+    end
+
+    should "have a translated object's translated attributes" do
+      assert @translation.attributes[TopicType.translatable_attributes.first]
+    end
+
+    should "be accessable from its topic_type" do
+      if assert(@topic_type.respond_to?(:translations))
+        assert @topic_type.translation_for(I18n.locale)
+      end
+    end
+
+    should "be able to retrieve just the translated attribute" do
+      if assert(@topic_type.respond_to?(:translations) && @topic_type.respond_to?(:name_translation_for))
+        assert @topic_type.name_translation_for(I18n.locale)
+      end
+    end
+
+    should "be able to retrieve its topic_type from the topic_type's persistence" do
+      assert @translation.translatable
+    end
+  end
+
+  context "When there is an TopicType needing translating" do
+    setup do
+      @topic_type = Factory.create(:topic_type, { :name => LOCALE_LABELS[:en] })
+    end
+
+    #Create id 1
+    should "create translation" do
+      translate_topic_type_for_locales(@topic_type, :zh)
+      assert @topic_type.translations.count == 1
+    end
+
+    should "not create translation if no translated text submitted" do
+      # arabic
+      I18n.locale = :ar
+      @topic_type.translate
+      assert @topic_type.translations.count == 0
+    end
+
+    should "not create translation if topic_type's original_locale is same as translation locale" do
+      I18n.locale = :en
+      @topic_type.translate(:name => LOCALE_LABELS[:en])
+      assert @topic_type.translations.count == 0
+    end
+
+    should "create translation and it should reflect current locale" do
+      # french
+      translate_topic_type_for_locales(@topic_type, :fr)
+      assert @topic_type.translation_for(:fr)
+    end
+
+    should "find topic_type with the proper translation for current locale" do
+      translate_topic_type_for_locales(@topic_type, :fi)
+
+      I18n.locale = :fi
+      # reloading topic_type should detect current locale and pass back translated version of object
+      @topic_type = TopicType.find(@topic_type.id)
+
+      assert_equal @topic_type.name, LOCALE_LABELS[:fi]
+    end
+
+    should "find topic_type with the proper translation for current locale and fallback to original's description for translatable attribute that hasn't been translated" do
+      translate_topic_type_for_locales(@topic_type, :fi)
+
+      original_description = @topic_type.description
+
+      I18n.locale = :fi
+      # reloading topic_type should detect current locale and pass back translated version of object
+      @topic_type = TopicType.find(@topic_type.id)
+
+      assert_equal @topic_type.name, LOCALE_LABELS[:fi]
+      assert_equal original_description, @topic_type.description
+    end
+
+    should "find topic_type with the proper translation for current locale when there is more than one translation" do
+      # add a couple translations
+      translate_topic_type_for_locales(@topic_type, [:fi, :fr])
+
+      # then back to finnish
+      I18n.locale = :fi
+
+      # reloading topic_type should detect current locale and pass back translated version of object
+      @topic_type = TopicType.find(@topic_type.id)
+
+      assert_equal @topic_type.name, LOCALE_LABELS[:fi]
+    end
+
+    # test dynamic finder
+    should "find topic_type with the proper translation for current locale when there is more than one translation and finding using dynamic finder" do
+      @topic_type = Factory.create(:topic_type, {:description => "a description"})
+
+      # add a couple translations
+      translate_topic_type_for_locales(@topic_type, [:fi, :fr])
+
+      # then back to finnish
+      I18n.locale = :fi
+
+      # reloading topic_type should detect current locale and pass back translated version of object
+      @topic_type = TopicType.find_by_description(@topic_type.description)
+
+      assert_equal @topic_type.name, LOCALE_LABELS[:fi]
+    end
+
+    should "after creating translations, if the topic_type is destroyed, the translations are destroyed" do
+      # add a couple translations
+      translate_topic_type_for_locales(@topic_type, [:fi, :fr])
+
+      translations_ids = @topic_type.translations.collect { |translation| translation.id }
+
+      @topic_type.destroy
+
+      remaining_translations = TopicType::Translation.find(translations_ids)
+
+      assert_equal 0, remaining_translations.size
+    end
+
+    should "when the topic_type is destroyed, when it has no translations, it should succeed in being destroyed" do
+      assert_equal 0, @topic_type.translations.size
+      assert @topic_type.destroy
+    end
+
+    teardown do
+      I18n.locale = @original_locale
+      @topic_type.destroy if @topic_type
+    end
+  end
+
+  context "When there are many topic_types being translated" do
+    setup do
+      # TODO: pull out this locale, not sure why before_save filter is not being called
+      @original_locale = I18n.locale
+    end
+
+    should "find topic_types with the proper translation for current locale" do
+      ids = many_setup
+
+      # reloading topic_type should detect current locale and pass back translated version of object
+      @topic_types = TopicType.find(ids)
+
+      many_tests
+    end
+
+    should "find topic_types with the proper translation for current locale using dynamic finder" do
+      description = "a description"
+      many_setup({:description => description})
+
+      # reloading topic_type should detect current locale and pass back translated version of object
+      @topic_types = TopicType.find_all_by_description(description)
+
+      many_tests(:fi => 10)
+    end
+
+    teardown do
+      I18n.locale = @original_locale
+      @topic_type.destroy if @topic_type
+    end
+  end
+
+  context "translations for an topic_type" do
+    setup do
+      I18n.locale = I18n.default_locale
+      @topic_type = Factory.create(:topic_type)
+      @translation_keys = LOCALE_LABELS.keys - [:en]
+      translate_topic_type_for_locales(@topic_type, @translation_keys)
+    end
+
+    should "be retrievable from translations method" do
+      assert_equal @translation_keys.size, @topic_type.translations.size
+    end
+
+    should "hae just locales be retrievable from translations_locales method" do
+      # these should be partial objects and not have any descriptions for other attributes
+      locale_keys = @topic_type.translations_locales.collect { |translation| translation.locale.to_sym if translation.name.nil? }.compact
+
+      assert_equal 0, (@translation_keys - locale_keys).size
+    end
+
+    should "have translation locales plus original local be retrievable as available_in_these_locales" do
+      locale_keys = @topic_type.available_in_these_locales.collect { |locale| locale.to_sym }
+
+      assert_equal 0, ( ([:en] + @translation_keys) - locale_keys ).size
+    end
+
+    should "have needed_in_these_locales method that returns locales that haven't been translated yet" do
+      TopicType::Translation.first(:topic_type_id => @topic_type.id, :locale => "zh").destroy
+      assert_equal [:zh], @topic_type.needed_in_these_locales.collect { |locale| locale.to_sym }
+    end
+
+    teardown do
+      I18n.locale = @original_locale
+      @topic_type.destroy if @topic_type
+    end
+  end
+
+
+
+  private
+
+  # see many_tests for what it expects
+  def many_setup(topic_type_spec = nil)
+    ids = Array.new
+    5.times do
+      I18n.locale = @original_locale
+      topic_type = topic_type_spec ? Factory.create(:topic_type, topic_type_spec) : Factory.create(:topic_type)
+      translate_topic_type_for_locales(topic_type, [:ar, :fr])
+      ids << topic_type.id
+    end
+
+    5.times do
+      I18n.locale = @original_locale
+      topic_type = topic_type_spec ? Factory.create(:topic_type, topic_type_spec) : Factory.create(:topic_type)
+      translate_topic_type_for_locales(topic_type, [:zh, :fi])
+      ids << topic_type.id
+    end
+
+    # excluding these from ids searched
+    5.times do
+      I18n.locale = @original_locale
+      topic_type = topic_type_spec ? Factory.create(:topic_type, topic_type_spec) : Factory.create(:topic_type)
+      translate_topic_type_for_locales(topic_type, [:fr, :fi])
+    end
+
+    I18n.locale = :fi
+    ids
+  end
+
+  # expect 5 en, 5 finnish, and none in french, chinese, or arabic
+  def many_tests(passed_amounts = { })
+    results_number_for = { :fi => 5, :en => 5, :fr => 0, :ar => 0, :zh => 0}
+    results_number_for.merge!(passed_amounts)
+
+    assert_equal results_number_for[:fi], @topic_types.select { |i| i.locale.to_sym == :fi }.size
+    assert_equal results_number_for[:en], @topic_types.select { |i| i.locale.to_sym == :en }.size
+    assert_equal results_number_for[:fr], @topic_types.select { |i| i.locale.to_sym == :fr }.size
+    assert_equal results_number_for[:ar], @topic_types.select { |i| i.locale.to_sym == :ar }.size
+    assert_equal results_number_for[:zh], @topic_types.select { |i| i.locale.to_sym == :zh }.size
+  end
+end

data/lib/kete_translatable_content.rb

@@ -0,0 +1,54 @@
+# Keep this file are bare as possible as it is used in migrations and routes
+# and does not need to pull in mongo libs or adjust view paths. Such code
+# should be done in ../rails/init.rb
+
+require 'kete_translatable_content/kete'
+
+Kete.define_reader_method_as('translatables',
+                             YAML.load(IO.read(File.join(File.dirname(__FILE__), '../config/translatables.yml'))))
+
+Kete.define_reader_method_as('translatable_system_settings', ['Pretty Site Name',
+                                                              'Flagging Tags',
+                                                              'Download Warning',
+                                                              'Blank Title',
+                                                              'Pending Flag',
+                                                              'Rejected Flag',
+                                                              'Blank Flag',
+                                                              'Reviewed Flag',
+                                                              'No Public Version Title',
+                                                              'No Public Version Description',
+                                                              'Government Website',
+                                                              'Default Page Keywords',
+                                                              'Default Page Description',
+                                                              'Additional Credits HTML',
+                                                              'Restricted Flag'
+                                                             ])
+
+Kete.define_reader_method_as('translatable_configurable_settings',
+                             ['additional_footer_content'])
+
+Kete.define_reader_method_as('translatable_tiny_mce_options', {
+  :width => '390',
+  :theme => 'advanced',
+  :theme_advanced_toolbar_location => "top",
+  :theme_advanced_toolbar_align => "left",
+  :theme_advanced_statusbar_location => "bottom",
+  :theme_advanced_buttons1 => %w{ bold italic underline strikethrough separator justifyleft justifycenter justifyright justifyfull separator indent outdent separator bullist numlist separator link unlink image },
+  :theme_advanced_buttons2 => %w{ formatselect fontselect fontsizeselect separator forecolor backcolor separator undo redo },
+  :theme_advanced_buttons3 => %w{ tablecontrols separator fullscreen separator code },
+  :theme_advanced_resizing => true,
+  :theme_advanced_resize_horizontal => false,
+  :convert_urls => false,
+  :content_css => "/stylesheets/base.css",
+  :plugins => %w{ table fullscreen paste }
+})
+
+def kete_translatable_content_ready?
+  kete_translatable_content_ready = true
+  Kete.translatables.keys.each do |name|
+    translatable = name.camelize.constantize.send(:new) rescue false
+    kete_translatable_content_ready = translatable && translatable.respond_to?(:original_locale)
+    break if kete_translatable_content_ready == false
+  end
+  kete_translatable_content_ready
+end

data/lib/kete_translatable_content/extensions/controllers/application_controller.rb

@@ -0,0 +1,202 @@
+ApplicationController.class_eval do
+
+  def kete_translatable_content?
+    controller, controller_as_key, action = params[:controller], params[:controller].singularize, params[:action]
+
+    translatable = Kete.translatables[controller_as_key]
+    return true if translatable && (translatable['views'] || []).include?(action)
+
+    # for some translatables, the controller is different than (or in addition to) its key.pluralized
+    !!Kete.translatables.find { |t|
+      (t.last['controllers'] || []).include?(controller) && (t.last['views'] || []).include?(action)
+    }
+  end
+  helper_method :kete_translatable_content?
+
+  def current_translatable_record
+    key = case params[:controller]
+          when 'images'
+            'still_image'
+          when 'audio'
+            'audio_recording'
+          else
+            params[:controller].singularize
+          end
+    
+    instance_variable_get('@' + key) || @item || @record || key.camelize.constantize.find(params[:id])
+  end
+  helper_method :current_translatable_record
+
+  before_filter :reload_standard_baskets
+  def reload_standard_baskets
+    Rails.logger.debug "[Kete Translatable Content]: Reloading Standard Baskets to be locale aware"
+    [@site_basket, @help_basket, @about_basket, @documentation_basket].each { |b| b.reload }
+  end
+
+  before_filter :redirect_unless_editing_original_locale, :only => ['edit', 'section', 'appearance', 'homepage_options']
+  def redirect_unless_editing_original_locale
+    action = params[:action]
+    editing_actions = ['edit', 'section', 'appearance', 'homepage_options']
+    if kete_translatable_content? && editing_actions.include?(action)
+      # check to see if we are in the special case for system settings
+      if action == 'section' && I18n.locale.to_sym != I18n.default_locale.to_sym
+        flash[:error] = I18n.t('kete_translatable.only_edit_original_locale')
+        I18n.locale = I18n.default_locale
+        return true
+      elsif action != 'section'
+        # handle everything else
+        translated = current_translatable_record
+        if I18n.locale.to_sym != translated.original_locale.to_sym
+          flash[:error] = I18n.t('kete_translatable.only_edit_original_locale')
+          redirect_to params.merge(:locale => translated.original_locale)
+          return false
+        end
+      end
+    end
+    true
+  end
+
+  # override mongo_translatable's target_locale locally
+  # because we only allow editing of the original locale (see redirect_unless_editing_original_locale)
+  # make sure we redirect to a locale the user has access to after translations are created or saved
+  def target_locale(options = {})
+    translation = options.delete(:translation) || @translation
+    translated = @translated || @translatable
+    override_locale = translated.original_locale if translated
+    override_locale || options.delete(:locale) || (translation.locale if translation) || I18n.locale
+  end
+
+  # override mongo_translatable's target_controller locally
+  # some kete translatables don't fall back under their own controller
+  def target_controller(options = {})
+    controller = options.delete(:controller)
+    if controller.nil?
+      key = options.delete(:translatable_params_name) || @translatable_params_name
+      if Kete.translatables[key] && Kete.translatables[key]['controllers'].present?
+        controller = Kete.translatables[key]['controllers'].first
+      else
+        controller = key.pluralize
+      end
+    end
+
+    if controller == 'tags'
+      if session[:original_item_return_to] && params[:action] == 'create'
+        url_parts = session[:original_item_return_to].split('/')
+        matching_parts = url_parts.select { |part| item_controllers.include?(part) }
+        controller = matching_parts.first
+      end
+    end
+
+    controller
+  end
+
+  # override mongo_translatable's target_action locally
+  # some kete translatables don't fall back under their own action
+  def target_action(options = {})
+    translated = options.delete(:translated) || @translated || options.delete(:translatable) || @translatable
+
+    case translated.class.name
+    when 'SystemSetting'       then 'index'
+    when 'Feed'                then 'homepage_options'
+    when 'ConfigurableSetting'
+      case translated.configurable_type
+      when 'Basket'
+        'appearance'
+      end
+    else
+      key = translated.class.name.tableize.singularize
+      if Kete.translatables[key] && Kete.translatables[key]['views'].present?
+        Kete.translatables[key]['views'].first
+      else
+        options.delete(:action) || params[:action]
+      end
+    end
+  end
+
+  # override mongo_translatable's target_id locally
+  # some kete translatables don't fall back under their own id
+  def target_id(options = {})
+    translated = options.delete(:translated) || @translated || options.delete(:translatable) || @translatable
+
+    case translated.class.name
+    when 'SystemSetting' then nil
+    when 'Feed' then translated.basket_id
+    when 'ConfigurableSetting' then translated.configurable_id
+    when 'Tag'
+      if session[:original_item_return_to] && params[:action] == 'create'
+        id_segment = session[:original_item_return_to].split('/').last
+        id = id_segment.include?('?') ? id_segment.split('?').first : id_segment
+      else
+        options.delete(:id) || translated
+      end
+    else
+      options.delete(:id) || translated
+    end
+  end
+  
+  alias_method(:oai_dc_first_element_for_orig, :oai_dc_first_element_for) unless self.new.respond_to?(:oai_dc_first_element_for_orig)
+  # we override to get the current locale's specific field value
+  # if available
+  def oai_dc_first_element_for(field_name, oai_dc)
+    first_field_element = oai_dc.xpath(".//dc:#{field_name}[@xml:lang=\"#{I18n.locale}\"]",
+                                       "xmlns:dc" => "http://purl.org/dc/elements/1.1/").first
+    
+    # we have a match for the locale, we're done
+    return first_field_element if first_field_element.present?
+      
+    # no match, return first match without lang specified
+    oai_dc.xpath(".//dc:#{field_name}",
+                 "xmlns:dc" => "http://purl.org/dc/elements/1.1/").first
+  end
+
+  before_filter :set_original_item_return_to, :only => :show
+  def set_original_item_return_to
+    if item_controllers.include?(params[:controller])
+      session[:original_item_return_to] = request.request_uri
+    end
+  end
+
+  before_filter :add_locale_to_attributes_in_params, :only => [:create, :update]
+
+  def add_locale_to_attributes_in_params
+    # only relevant to Kete.translatables
+    # return true if not Kete.translatables
+    params_attributes_key = nil
+    Kete.translatables.keys.each do |key|
+      if params.keys.include?(key)
+        params_attributes_key = key.to_sym
+        break
+      end
+    end
+
+    return true unless params_attributes_key
+
+    if params[params_attributes_key].present?  &&
+        params[params_attributes_key][:locale].blank?
+      params[params_attributes_key][:locale] = I18n.locale
+    end
+    true
+  end
+
+  private :add_locale_to_attributes_in_params
+
+  # modified to delete all locales' caches
+  def expire_fragment_for_all_versions(item, name = {})
+    name = name.merge(:id => item.id)
+    file_path = "#{RAILS_ROOT}/tmp/cache/#{fragment_cache_key(name).gsub(/(\?|:)/, '.')}.cache"
+    
+    possible_locales = item.respond_to?(:available_in_these_locales) ? item.available_in_these_locales : TranslationsHelper::available_locales.keys
+
+    starting_locale = possible_locales.select { |locale| file_path.include?("\/#{locale}\/") }.first
+
+    possible_locales.each do |locale|
+      with_locale_file_path = file_path
+
+      with_locale_file_path = file_path.sub("\/#{starting_locale}\/", "\/#{locale}\/") unless starting_locale == locale
+
+      File.delete(with_locale_file_path) if File.exists?(with_locale_file_path)
+    end
+    
+  end
+
+end