kete_translatable_content 0.1.0

data/lib/kete_translatable_content/extensions/tagging_overrides.rb

@@ -0,0 +1,27 @@
+# Redefines public_tags and private_tags to translate the returned tag objects
+# Make sure these are only done when the class they are being included into already responds
+# to public_tags, otherwise it'll end up trying to alias a method that doesn't exist
+
+module TaggingOverrides
+  unless included_modules.include? TaggingOverrides
+    def self.included(klass)
+      klass.class_eval do
+
+        if self.new.respond_to?(:public_tags)
+          alias_method(:public_tags_orig, :public_tags) unless self.new.respond_to?(:public_tags_orig)
+          def public_tags
+            Tag.swap_in_translation_for_multiple(public_tags_orig)
+          end
+        end
+
+        if self.new.respond_to?(:private_tags)
+          alias_method(:private_tags_orig, :private_tags) unless self.new.respond_to?(:private_tags_orig)
+          def private_tags
+            Tag.swap_in_translation_for_multiple(private_tags_orig)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/kete_translatable_content/extensions/tinymce_controller_valid_action_override.rb

@@ -0,0 +1,16 @@
+# this is necessary for translate ajax lighbox to be able to use tinymce
+# for description attribute
+# for ITEM_CLASSES
+module TinymceControllerValidActionOverride
+  unless included_modules.include? TinymceControllerValidActionOverride
+    def self.included(klass)
+      def add_show_as_uses_tiny_mce
+        instance_variable_set(:@uses_tiny_mce, true)
+      end
+
+      private :add_show_as_uses_tiny_mce
+
+      klass.send :before_filter, :add_show_as_uses_tiny_mce, :only => [:show]
+    end
+  end
+end

data/lib/kete_translatable_content/extensions/translation_from_version.rb

@@ -0,0 +1,105 @@
+# For classes where their ::Version subclass
+# is what has mongo_translatable declaration is on
+module TranslationFromVersion
+  unless included_modules.include? TranslationFromVersion
+    def locales_of_versions
+      @locales_of_versions ||= versions.find(:all,
+                                             :select => 'distinct locale').collect(&:locale)
+    end
+
+    # because of versioning, we may have an old version that is the same locale
+    # as original, modified to handle this case
+    def available_in_these_locales
+      locales = translations_locales.collect(&:locale) +
+        locales_of_versions
+
+      # we only need one mention of the locale
+      locales.uniq!
+
+      # get rid of any extra original_locale mentions
+      locales.delete(original_locale)
+
+      [original_locale] + locales
+    end
+
+    # sometimes all you need is only the locales of translations
+    # because of versioning we need to split out duplicates
+    def translations_locales
+      translations = self.class::Translation.all(self.class.as_foreign_key_sym => id,
+                                                 :select => 'locale')
+      uniq_translations = []
+      translations.each do |trans|
+        uniq_translations << trans unless uniq_translations.collect(&:locale).include?(trans.locale)
+      end
+      uniq_translations
+    end
+
+    # Get the current translation or the latest
+    def translation_for(locale)
+      translation = self.class::Translation.first(self.class.as_foreign_key_sym => id,
+                                                  :locale => locale,
+                                                  :version => self.version.to_s)
+
+      # none available for the specified version, get latest
+      translation ||= self.class::Translation.first(self.class.as_foreign_key_sym => id,
+                                                    :locale => locale)
+
+      # none available for locale at all
+      # see if there is an earlier version of the item
+      # in the locale specified
+      # find version with original_locale that matches
+      # revert_to version and return that
+      unless translation
+        version = versions.find_by_locale(locale)
+        if version.present?
+          # if attribute is an extended field
+          # doing a direct call on the version won't work
+          # so instantiating a tempory dummy item
+          dummy_attributes = version.attributes
+          dummy_attributes.delete(self.class.as_foreign_key_sym.to_s)
+          dummy_attributes.delete('id')
+          dummy = self.class.new(dummy_attributes)
+
+          translatable_attributes_from_version = Hash.new
+          translatable_attributes.each do |attr|
+            translatable_attributes_from_version[attr] = dummy.send(attr)
+          end
+          
+          dummy = nil
+
+          translatable_attributes_from_version[:locale] = locale
+
+          translation = self.class::Translation.new(translatable_attributes_from_version)
+        end
+      end
+      
+      translation
+    end
+
+    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,
+        :version => self.version
+      })
+
+      if translation_locale.to_s == original_locale.to_s
+        # 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
+  end
+end

data/lib/kete_translatable_content/kete.rb

@@ -0,0 +1,25 @@
+# overriding the system setting methods so we can pull translated versions out
+# for translatable ones
+class Kete
+  class << self
+    def localized_value_from(setting_id)
+      return nil unless I18n.default_locale != I18n.locale
+
+      SystemSetting.find(setting_id).constant_value
+    end
+
+    def reader_proc_for(setting)
+      method_name = setting.constant_name.downcase
+
+      Proc.new {
+        if setting.respond_to?(:takes_translations?) && setting.takes_translations?
+          localized_value = localized_value_from(setting.id)
+          return localized_value if localized_value
+        end
+
+        method_name = method_name.sub('?', '') if method_name.include?('?')
+        class_variable_get('@@' + method_name)
+      }
+    end
+  end
+end

data/lib/kete_translatable_content/overwrites/oai_dc_helpers_test.rb

@@ -0,0 +1,6 @@
+# overwrites for test/unit/oai_dc_helpers_test.rb
+HasValue.oai_dc_helpers_title_xml = "\"\#\{if zoom_class == 'Comment' then '<dc:title>Item</dc:title>' else '<dc:title xml:lang=\"' + I18n.default_locale.to_s + '\"' + '>Item</dc:title>' end\}\""
+HasValue.oai_dc_helpers_description_xml_when_only_xml = "\"\#\{if zoom_class == 'Comment' then '<dc:description><![CDATA[Description]]></dc:description>' else '<dc:description xml:lang=\"' + I18n.default_locale.to_s + '\"' + '><![CDATA[Description]]></dc:description>' end\}\""
+HasValue.oai_dc_helpers_short_summary_xml_when_only_xml = "\"<dc:description xml:lang=\"\#\{I18n.default_locale\}\"><![CDATA[Short Summary]]></dc:description>\""
+HasValue.oai_dc_helpers_tags_xml = "\"<dc:subject xml:lang=\"\#\{I18n.default_locale\}\"><![CDATA[tag]]></dc:subject>\""
+

data/rails/init.rb

@@ -0,0 +1,110 @@
+require 'mongo_translatable'
+require 'kete_translatable_content'
+require 'kete_translatable_content/extensions/extended_content_translation'
+require 'kete_translatable_content/extensions/translation_from_version'
+require "#{Rails.root}/test/has_value.rb"
+
+config.to_prepare do
+
+  # In development/production, we want to only setup stuff if IS_CONFIGURED is true
+  # In test mode however, we always want to have it, since IS_CONFIGURED won't be true
+  # at this stage, but it will be changed to true after Rails initializes.
+  if (IS_CONFIGURED || Rails.env.test?) && kete_translatable_content_ready?
+
+    Kete.translatables.each do |name, options|
+      args = [:mongo_translate, *options['translatable_attributes']]
+      args << { :redefine_find => options['redefine_find'],
+        :through_version => options["through_version"]}
+      
+      class_name = name.camelize
+      klass = class_name.constantize
+      klass.send(*args)
+
+      trans_class_name = class_name + "::Translation"
+      trans_klass = trans_class_name.constantize
+
+      if options["through_version"]
+        klass.send :include, TranslationFromVersion
+        trans_klass.send :update_keys_if_necessary_with, [:version]
+
+        trans_klass.ensure_index([[trans_klass.translatable_class.as_foreign_key_sym,
+                                   Mongo::ASCENDING],
+                                  [:version, Mongo::ASCENDING],
+                                  [:locale, Mongo::ASCENDING]],
+                                 :background => true,
+                                 :unique => true)
+      else
+
+        trans_klass.ensure_index([[trans_klass.translatable_class.as_foreign_key_sym,
+                                   Mongo::ASCENDING],
+                                  [:locale, Mongo::ASCENDING]],
+                                 :background => true,
+                                 :unique => true)
+
+      end
+    end
+
+    # precedence over a plugin or gem's (i.e. an engine's) app/views
+    # this is the way to go in most cases,
+    # but in our case we want to override the app's view.
+    # so we pop off our gem's app/views directory and put it at the front
+    kete_translatable_content_views_dir = File.join(directory, 'app/views')
+    # drop it from it's existing location if it exists
+    ActionController::Base.view_paths.delete kete_translatable_content_views_dir
+    # add it to the front of array
+    ActionController::Base.view_paths.unshift kete_translatable_content_views_dir
+
+    # load our locales
+    I18n.load_path += Dir[ File.join(File.dirname(__FILE__), '../config/locales/*.{rb,yml}') ]
+
+    # override some controllers and helpers to be kete translatable aware
+    exts = File.join(File.dirname(__FILE__), '../lib/kete_translatable_content/extensions/{controllers,helpers}/*')
+    # use Kernel.load here so that changes to the extensions are reloaded on each request in development
+    Dir[exts].each { |ext_path| Kernel.load(ext_path) }
+
+    # models we extend
+    Kete.extensions[:blocks] ||= Hash.new
+    Dir[ File.join(File.dirname(__FILE__), '../lib/kete_translatable_content/extensions/models/*') ].each do |ext_path|
+      key = File.basename(ext_path, '.rb').to_sym
+      Kete.extensions[:blocks][key] ||= Array.new
+      Kete.extensions[:blocks][key] << Proc.new { Kernel.load(ext_path) }
+    end
+
+    if Rails.env.test?
+      # tests we update with values that reflect this add-on's features
+      HasValue.overwrites[:blocks] ||= Hash.new
+      Dir[ File.join(File.dirname(__FILE__), '../lib/kete_translatable_content/overwrites/*') ].each do |ext_path|
+        key = File.basename(ext_path, '.rb').to_sym
+        HasValue.overwrites[:blocks][key] ||= Array.new
+        HasValue.overwrites[:blocks][key] << Proc.new { Kernel.load(ext_path) }
+      end
+    end
+
+    # extend the Generic Muted Worker to have the expire_locale method
+    MethodsForGenericMutedWorker.module_eval do
+      def clear_locale_cache(options = {})
+        locale_to_clear = options[:locale_to_clear]
+        raise unless locale_to_clear
+        
+        # WARNING: this relies on the fact that Kete's current caching scheme is file system based
+        # if an option for Memcache or other caching mechanism is used in the future
+        # this will need to be updated with logic to figure out correct clearing mechanism
+        file_path = "#{Rails.root}/tmp/cache/views/#{Kete.site_name}/#{locale_to_clear}"
+        FileUtils.rm_r(file_path, :force => true) if File.exist?(file_path) && File.directory?(file_path)
+      end
+
+      def rebuild_zoom_record_for(options = {})
+        item = options[:item]
+        raise unless item
+
+        item.prepare_and_save_to_zoom
+      end
+    end
+  end
+  if (IS_CONFIGURED || Rails.env.test?) && kete_translatable_content_ready?
+    Kete.translatables.each do |name, options|
+      class_name = name.camelize
+      class_name.constantize.send :include, ExtendedContentTranslation
+    end
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification 
+name: kete_translatable_content
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Walter McGinnis
+- Kieran Pilkington
+- Breccan McLeod-Lundy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-11 00:00:00 +13:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo_translatable
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Kete Translatable Content is a gem that is an add-on for Kete web applications that takes advantage of the mongo_translatable gem functionality. As you would expect, you use it to add the ability to translate content in your Kete web site.
+email: walter@katipo.co.nz
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+- README.rdoc.orig
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- app/views/active_scaffold_overrides/_show.html.erb
+- app/views/active_scaffold_overrides/_update_form.html.erb
+- app/views/active_scaffold_overrides/list.html.erb
+- app/views/baskets/_additional_footer_content_fields.html.erb
+- app/views/baskets/_rss_feed.html.erb
+- app/views/baskets/_side_bar_html.html.erb
+- app/views/configure/section.rhtml
+- app/views/layouts/translations.html.erb
+- app/views/topics/_content_wrapper_start.rhtml
+- app/views/translations/_form.html.erb
+- app/views/translations/_translatable_value.html.erb
+- app/views/translations/_translation_field_input.html.erb
+- app/views/translations/show.html.erb
+- app/views/translations/versioned_edit.html.erb
+- config/locales/en.yml
+- config/routes.rb
+- config/translatables.yml
+- generators/kete_translatable_content_migration/USAGE
+- generators/kete_translatable_content_migration/kete_translatable_content_migration_generator.rb
+- generators/kete_translatable_content_migration/templates/migration.rb
+- generators/kete_translatable_content_tests/USAGE
+- generators/kete_translatable_content_tests/kete_translatable_content_tests_generator.rb
+- generators/kete_translatable_content_tests/templates/configure_kete_content_translation_controller_and_routes_test.rb
+- generators/kete_translatable_content_tests/templates/configure_kete_content_translation_test.rb
+- generators/kete_translatable_content_tests/templates/kete_translatable_content_helper_test.rb
+- generators/kete_translatable_content_tests/templates/kete_translatable_content_migration_test.rb
+- generators/kete_translatable_content_tests/templates/kete_translatable_content_oai_dc_helpers_test.rb
+- generators/kete_translatable_content_tests/templates/kete_translatable_content_translations_test.rb
+- generators/kete_translatable_content_tests/templates/kete_translations_test.rb
+- generators/kete_translatable_content_tests/templates/mongo_factories.rb
+- generators/kete_translatable_content_tests/templates/mongo_test_helper.rb
+- generators/kete_translatable_content_tests/templates/mongo_translatable_test.rb
+- lib/kete_translatable_content.rb
+- lib/kete_translatable_content/extensions/controllers/application_controller.rb
+- lib/kete_translatable_content/extensions/controllers/audio_controller.rb
+- lib/kete_translatable_content/extensions/controllers/baskets_controller.rb
+- lib/kete_translatable_content/extensions/controllers/documents_controller.rb
+- lib/kete_translatable_content/extensions/controllers/images_controller.rb
+- lib/kete_translatable_content/extensions/controllers/topics_controller.rb
+- lib/kete_translatable_content/extensions/controllers/translations_controller.rb
+- lib/kete_translatable_content/extensions/controllers/video_controller.rb
+- lib/kete_translatable_content/extensions/controllers/web_links_controller.rb
+- lib/kete_translatable_content/extensions/extended_content_translation.rb
+- lib/kete_translatable_content/extensions/helpers/application_helper.rb
+- lib/kete_translatable_content/extensions/helpers/extended_fields_helper.rb
+- lib/kete_translatable_content/extensions/helpers/search_helper.rb
+- lib/kete_translatable_content/extensions/helpers/translations_helper.rb
+- lib/kete_translatable_content/extensions/models/audio_recording.rb
+- lib/kete_translatable_content/extensions/models/basket.rb
+- lib/kete_translatable_content/extensions/models/comment.rb
+- lib/kete_translatable_content/extensions/models/document.rb
+- lib/kete_translatable_content/extensions/models/still_image.rb
+- lib/kete_translatable_content/extensions/models/system_setting.rb
+- lib/kete_translatable_content/extensions/models/tag.rb
+- lib/kete_translatable_content/extensions/models/topic.rb
+- lib/kete_translatable_content/extensions/models/user.rb
+- lib/kete_translatable_content/extensions/models/video.rb
+- lib/kete_translatable_content/extensions/models/web_link.rb
+- lib/kete_translatable_content/extensions/oai_dc_helpers_overrides.rb
+- lib/kete_translatable_content/extensions/tagging_controller_overrides.rb
+- lib/kete_translatable_content/extensions/tagging_overrides.rb
+- lib/kete_translatable_content/extensions/tinymce_controller_valid_action_override.rb
+- lib/kete_translatable_content/extensions/translation_from_version.rb
+- lib/kete_translatable_content/kete.rb
+- lib/kete_translatable_content/overwrites/oai_dc_helpers_test.rb
+- rails/init.rb
+- README.rdoc.orig
+has_rdoc: true
+homepage: http://github.com/kete/kete_translatable_content
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An add-on to the Kete application to provide content translations.
+test_files: []
+