lolita-translation 0.3.3 → 0.5.0

data/lib/lolita-translation/configuration.rb

@@ -1,192 +1,67 @@
+require 'lolita-translation/translation_class_builder'
 module Lolita
   module Translation
 
-    module SingletonMethods
-      # Provides ability to add the translations for the model using delegate pattern.
-      # Uses has_many association to the ModelNameTranslation.
-      #
-      # For example you have model Article with attributes title and text.
-      # You want that attributes title and text to be translated.
-      # For this reason you need to generate new model ArticleTranslation.
-      # In migration you need to add:
-      #
-      #   create_table :article_translations do |t|
-      #     t.references :article, :null => false
-      #     t.string :locale, :length => 2, :null => false
-      #     t.string :name, :null => false
-      #   end
-      #
-      #   add_index :articles, [:article_id, :locale], :unique => true, :name => 'unique_locale_for_article_id'
-      #
-      # And in the Article model:
-      #
-      #   translations :title, :text
-      #
-      # This will adds:
-      #
-      # * named_scope (translated) and has_many association to the Article model
-      # * locale presence validation to the ArticleTranslation model.
-      #
-      # Notice: if you want to have validates_presence_of :article, you should use :inverse_of.
-      # Support this by yourself. Better is always to use artile.translations.build() method.
-      #
-      # For more information please read API. Feel free to write me an email to:
-      # dmitry.polushkin@gmail.com.
-      #
-      # ===
-      #
-      # You also can pass attributes and options to the translations class method:
-      #
-      #   translations :title, :text, :fallback => true, :writer => true, :nil => nil
-      #
-      # ===
-      #
-      # Configuration options:
-      # 
-      # * <tt>:fallback</tt> - if translation for the current locale not found.
-      #   By default true.
-      #   Uses algorithm of fallback:
-      #   0) current translation (using I18n.locale);
-      #   1) default locale (using I18n.default_locale);
-      #   2) :nil value (see <tt>:nil</tt> configuration option)
-      # * <tt>:reader</tt> - add reader attributes to the model and delegate them
-      #   to the translation model columns. Add's fallback if it is set to true.
-      # * <tt>:writer</tt> - add writer attributes to the model and assign them
-      #   to the translation model attributes.
-      # * <tt>:nil</tt> - when reader cant find string, it returns by default an
-      #   empty string. If you want to change this setting for example to nil,
-      #   add :nil => nil
-      #
-      # ===
-      #
-      # When you are using <tt>:writer</tt> option, you can create translations using
-      # update_attributes method. For example:
-      #
-      #   Article.create!
-      #   Article.update_attributes(:title => 'title', :text => 'text')
-      #
-      # ===
-      #
-      # <tt>translated</tt> named_scope is useful when you want to find only those
-      # records that are translated to a specific locale.
-      # For example if you want to find all Articles that is translated to an english
-      # language, you can write: Article.translated(:en)
-      #
-      # <tt>has_translation?(locale)</tt> method, that returns true if object's model
-      # have a translation for a specified locale
-      #
-      # <tt>translation(locale)</tt> method finds translation with specified locale.
-      #
-      # <tt>all_translations</tt> method that returns all possible translations in
-      # ordered hash (useful when creating forms with nested attributes).
-      def translations *attrs
-        @translations_config ||= Lolita::Translation::Configuration.new(self,*attrs)
-        if block_given?
-          yield @translations_config
-        end
-        @translations_config
+    def self.included(base)
+      base.extend(Lolita::Translation::ORM::ClassMethods)
+      base.class_eval do 
+        include Lolita::Translation::ORM::InstanceMethods
       end
     end
 
     class Configuration
-
-      attr_reader :klass, :options, :translation_class_name, :translation_class,:attrs
-
-      def initialize(base_class, *attrs)
-        @klass = base_class
-        @attrs = attrs
-        initialize_options
-        include_modules
-        initialize_default_attributes
-        extend_klass
-        extend_translation_class
-      end
-
-      private
-
-      def extend_klass
-        config = self
-        @klass.class_eval do
-    
-          class_attribute :has_translations_options
-          self.has_translations_options = config.options
-
-          class_attribute :columns_has_translations
-          self.columns_has_translations = (columns rescue []).collect{|col| col if config.attrs.include?(col.name.to_sym)}.compact
-          
-          class_attribute :translation_attrs
-          self.translation_attrs = config.attrs
-
-          has_many :translations, :class_name => config.translation_class_name, :foreign_key => config.translation_class.master_id, :dependent => :destroy
-          accepts_nested_attributes_for :translations, :allow_destroy => true, :reject_if => proc { |attributes| columns_has_translations.collect{|col| attributes[col.name].blank? ? nil : 1}.compact.empty? }
-          
-          scope :translated, lambda { |locale| 
-            where("#{translation_class.table_name}.locale = ?", locale.to_s).joins(:translations)
-          }
-
-          class << self
-            alias_method_chain :find, :translations
+      attr_reader :klass, :attributes, :translation_class, :options
+      alias :translation_attributes :attributes
+
+      def initialize(base_klass, *args, &block)
+        @options            = (args.respond_to?(:last) && args.last.is_a?(Hash) && args.pop) || {}
+        @klass              = base_klass
+        @attributes         = args
+        if base_klass.table_exists?
+          build_translation_class
+          if block_given?
+            block.call(self)
           end
         end
-        override_readers
       end
 
-      def extend_translation_class
-        translation_class.belongs_to @klass.name.demodulize.underscore.to_sym
-        translation_class.validates_presence_of :locale
-        translation_class.validates_uniqueness_of :locale, :scope => translation_class.master_id
+      def association_name
+        options[:association_name] || :translations
       end
 
-      def override_readers
-        if options[:reader]
-          attrs.each do |name|
-            override_reader(name)
-          end
+      def locales
+        if options[:locales] 
+          Lolita::Translation::Locales.new(options[:locales])
+        else
+          Lolita::Translation.locales
         end
       end
 
-      def override_reader(name)
-        @klass.send :define_method, name do
-          unless ::I18n.default_locale == ::I18n.locale
-            translation = self.translation(::I18n.locale)
-              if translation.nil?
-                if has_translations_options[:fallback]
-                  (self[name].nil? || self[name].blank?) ? has_translations_options[:nil] : self[name].set_origins(self,name)                    else
-                has_translations_options[:nil]
-              end
-            else
-              if @return_raw_data
-                (self[name].nil? || self[name].blank?) ? has_translations_options[:nil] : self[name].set_origins(self,name)
-              else
-                value = translation.send(name) and value.set_origins(self,name)
-              end
-            end
-          else
-            (self[name].nil? || self[name].blank?) ? has_translations_options[:nil] : self[name].set_origins(self,name)
-          end
-        end
+      def locale_field_name
+        options[:locale_field_name] || :default_locale
       end
 
-      def initialize_default_attributes
-        @translation_class_name = "#{@klass.name}Translation"
-        @translation_class = Lolita::Translation::TranslationModel.new(self).klass
+      def association_key
+        options[:association_key] || :"#{demodulized_class_name}_id"
       end
 
-      def include_modules
-        @klass.send(:include, Lolita::Translation::InstanceMethods)
-        @klass.extend(Lolita::Translation::ClassMethods)
+      def table_name
+        options[:table_name] || "#{klass.table_name}_translations"
       end
 
-      def initialize_options
-        @options = {
-          :fallback => true,
-          :reader => true,
-          :writer => false,
-          :nil => ''
-        }.merge(@attrs.extract_options!)
-        @options.assert_valid_keys([:fallback, :reader, :writer, :nil,:table_name])
+      def demodulized_class_name
+        klass.to_s.demodulize.underscore
+      end
+
+      private
+      
+      def build_translation_class
+        @builder            = Lolita::Translation::TranslationClassBuilder.new(self.klass, self)
+        @translation_class  = @builder.build_class
+        @builder.override_attributes(@attributes)
       end
 
     end
+
   end
-end
+end 

data/lib/lolita-translation/errors.rb

@@ -0,0 +1,15 @@
+module Lolita
+  module Translation
+    class ConfigurationNotInitializedError < StandardError
+      def initialize(klass)
+        super %Q{Configuration is not initialized for #{klass}. Try to call #translate in class.}
+      end
+    end
+
+    class NoBuilderForClassError < ArgumentError
+      def initialize(klass)
+        super %Q{No builder for #{klass}. See available builder in /lib/lolita-translation/builder directory.}
+      end
+    end 
+  end
+end

data/lib/lolita-translation/locale.rb

@@ -0,0 +1,32 @@
+require 'i18n'
+
+module Lolita
+  module Translation
+
+    class Locale
+      attr_accessor :name 
+      alias :short_name :name 
+
+      def initialize(name)
+        @name = name
+      end
+
+      def humanized_short_name
+        self.name.to_s.sub(/^(\w{1})(\w+)/) do 
+          "#{$1.to_s.upcase}#{$2}"
+        end
+      end
+
+      def active?
+        self.name == current_locale
+      end
+
+      private
+
+      def current_locale
+        ::I18n.locale
+      end
+    end
+
+  end
+end

data/lib/lolita-translation/locales.rb

@@ -0,0 +1,62 @@
+require 'lolita-translation/locale'
+
+module Lolita
+  module Translation
+
+    class Locales
+      include Enumerable
+
+      def initialize(locale_names)
+        @locale_names = locale_names
+      end
+
+      def each
+        populate_locales!
+        @locales.each do |locale|
+          yield locale
+        end
+      end
+
+      def by_resource_locale(resource)
+        r_locale = resource_locale(resource)
+        self.inject([]) do |result, locale|
+          if r_locale.to_s == locale.name.to_s
+            result.unshift(locale)
+          else
+            result.push(locale)
+          end
+          result 
+        end
+      end
+
+      def locale_names
+        l_names = if @locale_names.respond_to?(:call)
+          @locale_names.call
+        else
+          @locale_names
+        end
+        l_names.sort
+      end
+
+      def active
+        self.detect{|locale| locale.active?}
+      end
+
+      private
+
+      def resource_locale(resource)
+        transl_record = resource.translation_record
+        transl_record && transl_record.default_locale || ::I18n.locale
+      end
+
+      def populate_locales!
+        unless @locales 
+          @locales = locale_names.map do |locale_name|
+            Lolita::Translation::Locale.new(locale_name)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/lolita-translation/lolita/component_hooks.rb

@@ -0,0 +1,49 @@
+Lolita::Hooks.component(:"/lolita/configuration/tab/error_msg").before do
+  tab = self.component_locals[:tab]
+  if tab.translatable?
+    self.send(:render_component,"lolita/translation",:switch, :tab => tab)
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/tab/fields").after do
+  tab = self.component_locals[:tab]
+  if tab.translatable?  
+    self.render_component tab.build_translations_nested_form(self.resource)
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/tab/fields").around do
+  tab = self.component_locals[:tab]
+  if tab.translatable?
+    content = nil
+    resource.in(resource.original_locale) do 
+      content = let_content
+    end
+    self.send(:render_component,"lolita/translation",:language_wrap, {
+      :tab => tab, 
+      :content => content, 
+      :active => true,
+      :translation_locale => resource.original_locale
+    })
+  else
+    let_content
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/nested_form/fields").around do
+  tab = self.component_locals[:nested_form].parent
+  if tab.translatable? && current_form.object.respond_to?(:locale)
+    self.send(:render_component,"lolita/translation",:language_wrap, {
+      :tab => tab, 
+      :content => let_content, 
+      :active => false,
+      :translation_locale => current_form.object.locale
+    })
+  else
+    let_content
+  end
+end
+
+Lolita::Hooks.component(:"/lolita/configuration/tabs/display").before do
+  self.render_component "lolita/translation", :assets
+end

data/lib/lolita-translation/lolita/tab_extension.rb

@@ -0,0 +1,113 @@
+module Lolita
+  module Configuration
+    module Tab
+
+      class Base
+
+        # This class encapsulate all logic about tab that are translatable, original tab uses it only when it is neccessary
+        class TranslationTabExtension
+          attr_reader :tab, :dbi
+          def initialize(tab)
+            @tab = tab
+            @dbi = tab.dbi
+          end
+
+          def translatable?
+            is_dbi_klass_translatable? && tab_has_translatable_fields?
+          end
+
+          def build_form(resource) 
+            resource.build_nested_translations 
+            nested_form = create_translations_nested_form(resource)
+            nested_form 
+          end
+
+          def add_original_locale_field(fields)
+            if is_dbi_klass_translatable? && !exist_original_locale_field?(fields) && tab_has_translatable_fields?(fields)
+              locale_field = Lolita::Configuration::Factory::Field.add(dbi, :original_locale, :string, :builder => :hidden)
+              fields << locale_field 
+            end
+          end
+
+          private
+
+          def create_translations_nested_form(resource)
+            nested_form             = Lolita::Configuration::NestedForm.new(tab, translations_association_name) 
+            nested_form.expandable  = false
+            nested_form.field_style = :normal
+            nested_form.fields      = fields_for_translation_nested_form(nested_form)
+            nested_form
+          end
+
+          def fields_for_translation_nested_form(nested_form)
+            t_attributes = dbi_klass_translation_attributes
+            t_fields = tab.fields.reject do|field|
+              !t_attributes.include?(field.name.to_sym)
+            end
+            t_fields << Lolita::Configuration::Factory::Field.add(nested_form.dbi,:locale,:string, :builder => :hidden)
+            t_fields
+          end
+
+          def exist_original_locale_field?(fields)
+            !!fields.detect do |field|
+              field.name == :original_locale
+            end
+          end
+
+          def is_dbi_klass_translatable?
+            (dbi.klass.respond_to?(:translations_configuration) && dbi.klass.respond_to?(:translate))
+          end
+
+          def tab_has_translatable_fields?(fields = nil)
+            (collect_possibly_translateble_fields(fields) & dbi_klass_translation_attributes).any?
+          end
+
+          def dbi_klass_translation_attributes
+            transl_configuration = dbi.klass.translations_configuration
+            transl_configuration && transl_configuration.attributes || []
+          end
+
+          def translations_association_name
+            translations_configuration.association_name
+          end
+
+          def locale_field_name
+            translations_configuration.locale_field_name
+          end
+
+          def translations_configuration
+            dbi.klass.translations_configuration
+          end
+
+
+          def collect_possibly_translateble_fields(fields = nil)
+            (fields || tab.fields).reject{|field|
+              field.dbi != dbi
+            }.map(&:name)
+          end
+
+        end
+
+        def fields
+          translation_tab_extension.add_original_locale_field(@fields)
+          @fields
+        end
+
+        def translatable?
+          translation_tab_extension.translatable?
+        end
+
+        def build_translations_nested_form(resource) 
+          translation_tab_extension.build_form(resource)
+        end
+
+        private
+
+        def translation_tab_extension
+          @translation_tab_extension ||= TranslationTabExtension.new(self)
+        end
+      end
+
+    end
+  end
+end