kete_translatable_content 0.1.0

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

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '../tinymce_controller_valid_action_override')
+require File.join(File.dirname(__FILE__), '../tagging_controller_overrides')
+
+AudioController.class_eval do
+  include TinymceControllerValidActionOverride
+  include TaggingControllerOverrides
+end

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

@@ -0,0 +1,3 @@
+BasketsController.class_eval do
+  uses_tiny_mce :options => Kete.translatable_tiny_mce_options, :only => %w{ edit appearance }
+end

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

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '../tinymce_controller_valid_action_override')
+require File.join(File.dirname(__FILE__), '../tagging_controller_overrides')
+
+DocumentsController.class_eval do
+  include TinymceControllerValidActionOverride
+  include TaggingControllerOverrides
+end

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

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '../tinymce_controller_valid_action_override')
+require File.join(File.dirname(__FILE__), '../tagging_controller_overrides')
+
+ImagesController.class_eval do
+  include TinymceControllerValidActionOverride
+  include TaggingControllerOverrides
+end

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

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '../tinymce_controller_valid_action_override')
+require File.join(File.dirname(__FILE__), '../tagging_controller_overrides')
+
+TopicsController.class_eval do
+  include TinymceControllerValidActionOverride
+  include TaggingControllerOverrides
+end

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

@@ -0,0 +1,209 @@
+TranslationsController.class_eval do
+  uses_tiny_mce :options => Kete.translatable_tiny_mce_options, :only => %w{ new edit }
+
+  include WorkerControllerHelpers
+
+  before_filter :params_version_to_latest_if_necessary, :only => :new
+
+  after_filter :expire_locale_cache, :only => [:create, :update]
+  after_filter :update_zoom_record_if_applicable, :only => [:create, :update]
+
+  def edit
+    @translation = @translated.translation_for(params[:id]) || @translatable_class::Translation.find(params[:id])
+    if @translated.respond_to?("version")
+      @translation = @translated.translate(:locale => (params[:to_locale] || I18n.locale.to_s)) unless @translation.version.to_i == @translated.version.to_i
+    end
+
+    render :template => "translations/versioned_edit"
+  end
+
+  # POST /translations
+  # POST /translations.xml
+  def create
+    translation_params = params[:translation] || params[@translatable_params_name + '_translation']
+    params[:version] ||= params[@translatable_key][:version] if params[@translatable_key]
+    translation_params[:version] = params[:version].to_i if params[:version]
+    @translation = @translatable.translate(translation_params)
+
+    respond_to do |format|
+      if @translation.save
+        flash[:notice] = t('translations.controllers.created')
+        # we redirect to translated object in the new translated version
+        # assumes controller name is tableized version of class
+        format.html { redirect_to url_for_translated(:locale => I18n.locale) }
+        # TODO: adjust :location accordingly for being a nested route
+        format.xml  { render :xml => @translation, :status => :created, :location => @translation }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @translation.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /translations/1
+  # PUT /translations/1.xml
+  def update
+    respond_to do |format|
+      translation_params = params[:translation] || params[@translatable_params_name + '_translation']
+      params[:version] ||= params[@translatable_key][:version] if params[@translatable_key]
+      translation_params[:version] = params[:version].to_i if params[:version]
+      if @translation.update_attributes(translation_params)
+        flash[:notice] = t('translations.controllers.updated')
+        format.html { redirect_to url_for_translated(:locale => I18n.locale) }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @translation.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  private
+
+  def get_translation
+    @translation = @translated.translation_for(params[:id]) || @translatable_class::Translation.find(params[:id])
+    if @translated.respond_to?("version")
+      @translation = @translated.translate(:locale => (params[:to_locale] || I18n.locale.to_s)) unless @translation.version.to_i == @translated.version.to_i
+    end
+  end
+
+  %w{translatable translated}.each do |term|
+    define_method("get_" + term) do
+      params[:version] ||= params[@translatable_key][:version] if params[@translatable_key]
+
+      value = @translatable_class.find(params[@translatable_key])
+
+      value.revert_to(params[:version].to_i) if params[:version]
+
+      # handle case of editing translation from another locale than original
+      # unfortunately requires reloading of object
+      if value.locale != value.original_locale &&
+          params[:controller] == 'translations' &&
+          params[:action] == 'edit'
+
+        starting_locale = I18n.locale 
+        I18n.locale = value.original_locale
+
+        if params[:version]
+          value.revert_to(params[:version].to_i)
+        else
+          value.reload
+        end
+
+        I18n.locale = starting_locale
+      end
+
+      instance_variable_set("@" + term, value)
+    end
+  end
+
+  #Expire the cache of documents related to this record works on 
+  #a wider scale if the record is relevant to the global UI.
+  def expire_locale_cache
+    #Kete items to be cleared individually
+    @translatable = @translation.respond_to?("translatable") ? @translation.translatable : @translation
+    if ITEM_CLASSES.include?(@translatable_class.to_s)
+      expire_show_caches_for(@translatable)
+
+      #Clear out the available for_list which may be updated
+      clear_header_fragments_for(@translated)
+      @translatable.translations.each do |translation|
+        clear_header_fragments_for(translation.translatable)
+      end
+
+      return true
+    elsif @translatable.is_a?(Tag)
+      # we need to expire the tag part
+      # for everything with that tag
+      @translatable.taggings.each do |tagging|
+        item = tagging.taggable
+
+        # sort of redundent, but achieves what we want
+        item.locale = @translatable.locale
+
+        controller = zoom_class_controller(item.class.name)
+        part = 'secondary_content_tags_[privacy]'
+        resulting_part = cache_name_for(part, 'public')
+        expire_fragment_for_all_versions_and_locale(item, { :controller => controller, :action => 'show', :id => item, :part => resulting_part })
+        resulting_part = cache_name_for(part, 'private')
+        expire_fragment_for_all_versions_and_locale(item, { :controller => controller, :action => 'show', :id => item, :part => resulting_part })
+      end
+    elsif @translatable.is_a?(Feed)
+      @translatable.clear_caches
+    else
+      expire_all_locale_caches
+    end
+  end
+
+  def clear_header_fragments_for(item)
+    item_class = item.class.name
+    controller = zoom_class_controller(item_class)
+    @privacy_type ||= (item.private? ? "private" : "public")
+    return unless ITEM_CLASSES.include?(item_class)
+    part = 'details_first_[privacy]'
+    resulting_part = cache_name_for(part, @privacy_type)
+    expire_fragment_for_all_versions_and_locale(item, { :controller => controller, :action => 'show', :id => item, :part => resulting_part })
+  end
+
+  def expire_fragment_for_all_versions_and_locale(item, name = {})
+    #blank title or url_for comes up with something it shouldn't
+    name[:id].title = ""  if name[:id].title
+
+    name = name.merge(:id => item.id)
+    
+    file_path = "#{RAILS_ROOT}/tmp/cache/#{fragment_cache_key(name).gsub(/(\?|:)/, '.')}.cache"
+    file_path.sub!("\/#{@translatable.locale}\/", "\/#{item.locale}\/")
+    File.delete(file_path) if File.exists?(file_path)
+  end
+
+  def expire_all_locale_caches
+      # this is the big hammer for translation clearing # it does the entire locale's cache if a translation changes
+      # only use on UI element related models
+      # Kete items (i.e. user generated content) should be done on an item by item basis
+      expire_locale = @translatable.locale
+      method_name = "clear_locale_cache"
+      options = { :locale_to_clear => expire_locale }
+
+      worker_type = :generic_muted_worker
+      worker_key = worker_key_for("generic_muted_worker_#{method_name}_#{expire_locale}")
+
+      # only allow a single cache clearing to happen at once
+      MiddleMan.new_worker( :worker => worker_type,
+                           :worker_key => worker_key )
+
+      MiddleMan.worker(worker_type, worker_key).async_do_work( :arg => { :method_name => method_name, :options => options } )
+      true
+  end
+
+  # filter that will trigger zoom record rebuild for translatable
+  # if translatable.class is in ITEM_CLASSES
+  def update_zoom_record_if_applicable
+    @translatable = @translation.respond_to?("translatable") ? @translation.translatable : @translation
+    if ITEM_CLASSES.include?(@translatable.class.name)
+      rebuild_zoom_for_translatable
+    end
+  end
+
+  def rebuild_zoom_for_translatable
+    method_name = "rebuild_zoom_record_for"
+    options = { :item => @translatable }
+    
+    worker_type = :generic_muted_worker
+    worker_key = worker_key_for("generic_muted_worker_#{method_name}_#{@translatable_class.to_s}_#{@translatable.id}")
+
+    # only allow a single cache clearing to happen at once
+    MiddleMan.new_worker( :worker => worker_type,
+                          :worker_key => worker_key )
+
+    MiddleMan.worker(worker_type, worker_key).async_do_work( :arg => { :method_name => method_name, :options => options } )
+    true
+  end
+  
+  # default to latest version, unless it is passed in
+  # private versions should pass version
+  def params_version_to_latest_if_necessary
+    if params[:version].blank? && @translatable.respond_to?(:version)
+      params[:version] = @translatable.version
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '../tinymce_controller_valid_action_override')
+require File.join(File.dirname(__FILE__), '../tagging_controller_overrides')
+
+VideoController.class_eval do
+  include TinymceControllerValidActionOverride
+  include TaggingControllerOverrides
+end

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

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '../tinymce_controller_valid_action_override')
+require File.join(File.dirname(__FILE__), '../tagging_controller_overrides')
+
+WebLinksController.class_eval do
+  include TinymceControllerValidActionOverride
+  include TaggingControllerOverrides
+end

data/lib/kete_translatable_content/extensions/extended_content_translation.rb

@@ -0,0 +1,54 @@
+# for ZOOM_CLASSES, extended_content is translatable_attribute
+# however, in mongodb we store indivdual values for the extended fields
+# and then we swap in actual translatable extended field values via individual
+# extended field setter methods (method missing methods)
+# the advantage is that we only have to tell mongo_translatable that extended_content
+# is translatable at the time of system startup
+# and we can go on declaring new extended fields dynamically
+module ExtendedContentTranslation
+  unless included_modules.include? ExtendedContentTranslation
+    def self.included(base)
+
+      #Send define method because scopes are not playing nicely together
+      base.send(:define_method, :translatable_attributes) do
+        return @translatable_attributes if @translatable_attributes.present?
+
+        # klass is ::Version classes parent namespace wise
+        klass = self.class
+
+        type = klass == Topic ? topic_type : ContentType.find_by_class_name(klass.name)
+
+        if type
+          # fields = type.mapped_fields.select { |f| ['text', 'textarea', 'choice', 'autocomplete'].include?(f.ftype) }
+          fields = type.mapped_fields.select { |f| ['text', 'textarea',].include?(f.ftype) }
+
+          type_translatable_attributes = fields.collect do |f|
+            unless f.multiple
+              f.label_for_params.to_sym
+            else
+              [f.label_for_params.to_sym, Array]
+            end
+          end
+
+          klass::Translation.update_keys_if_necessary_with(type_translatable_attributes)
+
+          update_translation_for_methods_if_necessary_with(type_translatable_attributes)
+
+          type_translatable_attribute_keys_only = type_translatable_attributes.collect do |a|
+            if a.is_a?(Array)
+              a[0]
+            else
+              a
+            end
+          end
+
+          @translatable_attributes = self.class.translatable_attributes + type_translatable_attribute_keys_only
+        else
+          @translatable_attributes = self.class.translatable_attributes
+        end
+        @translatable_attributes
+      end
+    end
+  end
+end
+

data/lib/kete_translatable_content/extensions/helpers/application_helper.rb

@@ -0,0 +1,156 @@
+ApplicationHelper.module_eval do
+  # lighboxes only used when user is logged in
+  def lightbox?
+    logged_in?
+  end
+
+  def tags_for(item)
+    html_string = String.new
+
+    return html_string if item.tags.blank?
+
+    html_string = "<p>#{t('application_helper.tags_for.tags')} "
+    item_tags = item.tags
+
+    item_tags.each_with_index do |tag,index|
+      html_string += link_to_tagged(tag, item.class.name)
+
+      # since tags-list is cached,
+      # we have to assume the user is logged out, use false for lightbox
+
+      # all we need to know is whether this tag is in the I18n.locale
+      # if not, provide translate link
+      unless tag.locale == I18n.locale
+        html_string += '<sup class="badge">' +
+          translate_link(tag,
+                         :lightbox => false,
+                         :action => 'new') +
+          '</sup>'
+      end
+
+      html_string += ", " unless item_tags.size == (index + 1)
+    end
+    html_string += "</p>"
+
+    html_string
+  end
+
+  def display_label_for(field_or_choice)
+    field_or_choice.label_translation_for(I18n.locale) || field_or_choice.label
+  end
+
+  def combined_tranlation_links
+    version = (current_translatable_record.respond_to?(:version) && current_translatable_record.version)
+    html = ''
+    html += '<div class="content-wrapper-submenu" id="translations">' + I18n.t('translations.available_in')
+    html += '<ul class="horizontal-list">'
+    
+    available_locale_links = raw_available_in_locales_links(current_translatable_record, :params => {:version => version })
+
+    available_locales = available_locale_links.collect { |link| link[:locale].to_s }
+
+    available_locale_links.each_with_index do |link, i|
+      html += "<li#{' class="first"' if i == 0 }>"
+      html += link[:link]
+
+      unless link[:locale] == current_translatable_record.original_locale
+        record_translation_for_locale = current_translatable_record.translation_for(link[:locale])
+
+        if record_translation_for_locale &&
+            current_translatable_record.version.to_i > record_translation_for_locale.version.to_i
+          html += '<sup class="badge">' + I18n.t('translations.old') + '</sup>'
+          # drop locale from available_locales, so we get the translate link
+          available_locales.delete(link[:locale].to_s)
+        end
+      end
+
+      html += '</li>'
+    end
+
+    translate_link_version = nil 
+
+    if version &&
+        current_translatable_record.respond_to?(:private?) &&
+        current_translatable_record.private?
+      
+      translate_link_version = version
+    end
+
+    if current_translatable_record.original_locale != I18n.locale &&
+        !available_locales.include?(I18n.locale.to_s)
+      html += '<li id="translate">' + translate_link(current_translatable_record,
+                                                     :lightbox => lightbox?,
+                                                     :action => 'new',
+                                                     :params => {:version => translate_link_version}) + '</li>'
+    elsif current_translatable_record.original_locale == I18n.locale && available_locales.size == 1
+      other_locales = TranslationsHelper::available_locales.keys - [current_translatable_record.original_locale]
+
+      html += '<li id="translate">' + translate_link(current_translatable_record,
+                                                     :lightbox => lightbox?,
+                                                     :action => 'new',
+                                                     :params => {:version => translate_link_version,
+                                                       :to_locale => other_locales.first}) + '</li>'
+    end
+
+    translations_params = Hash.new
+    params.each do |k,v|
+      translations_params[k] = v unless %w(action controller id).include?(k.to_s)
+    end
+
+    manage_links = manage_translations_links_for(current_translatable_record,
+                                                 available_locales - [current_translatable_record.original_locale],
+                                                 { :params => translations_params })
+
+    
+    if manage_links.present? && logged_in?
+      # drop the 'delete' link unless a moderator or above
+      # a little brittle, as it relies on knowledge that ( edit | delete ) html
+      # as returned by helper method has | when (edit | delete) rather than manage
+      unless @at_least_a_moderator && manage_links.include?('|')
+
+        # only moderators and above can have access to 'delete'
+        manage_links = ' ' + manage_links.split('|')[0]
+      end
+
+      html += '<li id="manage-translations">(' + manage_links + ')</li>' 
+    end
+
+    html += '</ul>
+            </div>'
+
+    translatable_lightbox_js_and_css
+
+    html
+  end
+
+  def add_ons_item_form_beginning(form=nil)
+    return unless form
+    locale_dropdown(form, :default => I18n.locale) 
+  end
+
+  # redefining, because under certain circumstances
+  # user should get a confirm dialog before going to edit page
+  def link_to_edit_for(item)
+    t_key = t("topics.actions_menu.edit")
+
+
+    args = ["<span class=\"edit-link\">#{t_key}</span>",
+            { :action => :edit,
+              :id => item,
+              :private => params[:private]}]
+    
+    additional_options = { :tabindex => '1' }
+    
+    # translation for this locale exists,
+    # but it isn't the original locale
+    if item.original_locale != I18n.locale &&
+        item.available_in_these_locales.include?(I18n.locale)
+
+        additional_options[:confirm] = t('translations.are_you_sure_for_item_edit')
+    end
+
+    args << additional_options
+
+    link_to(*args)
+  end
+end