lolita-translation 0.3.3 → 0.5.0

data/lib/lolita-translation/migrator.rb

@@ -0,0 +1,56 @@
+module Lolita
+  module Translation
+    
+    class Migrator
+
+      attr_reader :klass,:config
+
+      def initialize(base_class)
+        @klass  = base_class
+        @config = @klass.translations_configuration 
+      end
+
+      def migrate
+        raise StandardError, "#{self.class} must implement this method"
+      end
+
+      class << self
+        def create(klass)
+          if active_record?(klass)
+            Lolita::Translation::Migrators::ActiveRecordMigrator.new(klass)
+          elsif mongoid?(klass)
+            Lolita::Translation::Migrators::MongoidMigrator.new(klass)
+          end
+        end
+
+        private
+
+        def active_record?(klass)
+          Lolita::Translation::Utils.active_record_class?(klass)
+        end
+
+        def mongoid?(klass)
+          Lolita::Translation::Utils.mongoid_class?(klass)
+        end
+      end
+
+      private
+
+      def switch_stdout
+        begin
+          out = StringIO.new
+          $stdout = out
+          yield
+        ensure
+          $stdout = STDOUT
+        end
+      end
+
+    end
+
+  
+  end
+end
+
+require 'lolita-translation/migrators/active_record_migrator'
+require 'lolita-translation/migrators/mongoid_migrator'

data/lib/lolita-translation/migrators/active_record_migrator.rb

@@ -0,0 +1,93 @@
+require 'lolita-translation/migrator'
+module Lolita
+  module Translation
+    module Migrators
+      class ActiveRecordMigrator < Lolita::Translation::Migrator 
+
+        def migrate
+          switch_stdout do 
+            unless table_exist?
+              create_table
+              add_indexes
+              reset_class_column_information
+            else
+              if change_table
+                reset_class_column_information
+              end
+            end
+          end
+        end
+
+        private
+
+        def create_table
+          ActiveRecord::Migration.create_table config.table_name do |t|
+            t.integer config.association_key, :null => false
+            t.string  :locale, :null => false, :limit => 5
+            config.attributes.each do |attr|
+              if col = column(attr)
+                t.send(col.type, attr)
+              end
+            end
+          end
+        end
+
+        def change_table
+          removed_columns.inject(false) do |result,attribute|
+            ActiveRecord::Migration.remove_column(config.table_name, attribute)
+            true
+          end ||
+          config.attributes.inject(false) do |result, attribute|
+            if !translations_column(attribute)
+              if col = column(attribute)
+                ActiveRecord::Migration.add_column(config.table_name, attribute, col.type)
+                result = true
+              end
+            end
+            result
+          end
+        end
+
+        def add_indexes
+          ActiveRecord::Migration.add_index(
+            config.table_name, 
+            [config.association_key, :locale], {
+              :unique => true, 
+              :name => "#{config.table_name}_comb"
+            }
+          )
+          ActiveRecord::Migration.add_index(
+            config.table_name, 
+            config.association_key,{
+              :name => "#{config.table_name}_sim"
+            }
+          )
+        end
+
+        def content_columns
+          config.translation_class.column_names - ["id", "locale", config.association_key.to_s]
+        end
+
+        def removed_columns
+          content_columns - config.attributes.map{|a| a.to_s }
+        end
+        def reset_class_column_information
+          config.translation_class.reset_column_information
+        end
+
+        def table_exist?
+          ActiveRecord::Migration.table_exists?(config.table_name)
+        end
+
+        def column(name)
+          klass.columns_hash[name.to_s]
+        end
+
+        def translations_column(name)
+          config.translation_class.columns_hash[name.to_s]
+        end 
+      end
+
+    end
+  end
+end

data/lib/lolita-translation/migrators/mongoid_migrator.rb

@@ -0,0 +1,81 @@
+require 'lolita-translation/migrator'
+
+module Lolita
+  module Translation
+    module Migrators      
+      class MongidMigrator
+
+        def migrate
+          if collection_exist?
+            create_collection_struct
+            add_indexes
+          else
+            change_collection_struct
+          end
+           unless translations_class.fields["locale"]
+              
+            else
+              
+            end
+        end
+
+        private
+
+        def create_collection_struct
+          orig_config = config
+
+          config.translations_class.class_eval do
+            field(orig_config.association_key, :type => Integer)
+            field :locale, :type => String
+            orig_config.attributes.each do |attribute|
+              if col = field(attribute)
+                field col.name, :type => col.type
+              end
+            end
+          end
+        end
+
+        def change_collection_struct
+          config.attributes.each do |attribute|
+            unless translations_field(attribute)
+              if col = field(attribute)
+                config.translations_class.field(col.name, :type => col.type)
+              end
+            end
+          end
+        end
+
+        def add_indexes
+          orig_config = config 
+
+          config.translations_class.class_eval do 
+            index(
+              [
+                [ orig_config.association_key, Mongo::ASCENDING ],
+                [ :locale, Mongo::ASCENDING ]
+              ],
+              unique: true, background: true
+            )
+            index( orig_config.association_key, Mongo::ASCENDING, background: true)
+          end
+        end
+
+        def collection_exist?
+          config.translations_class.fields["locale"]
+        end
+
+        def field(name)
+          klass.fields.detect do |field|
+            field.name.to_s == name.to_s
+          end
+        end
+
+        def translations_field(name)
+          config.translations_class.fields.detect do |field|
+            field.name.to_s == name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lolita-translation/orm/mixin.rb

@@ -0,0 +1,57 @@
+module Lolita
+  module Translation
+
+    module ORM
+
+      module ClassMethods
+        def translate *args, &block
+          @translations_configuration ||= Lolita::Translation::Configuration.new(self,*args,&block)
+        end
+
+        def translations_configuration
+          unless @translations_configuration
+            raise Lolita::Translation::ConfigurationNotInitializedError.new(self)
+          else
+            @translations_configuration
+          end
+        end
+
+        def sync_translation_table!
+          migrator = Lolita::Translation::Migrator.create(self)
+          migrator.migrate
+        end
+
+      end
+
+      module InstanceMethods
+
+        def translations_configuration
+          self.class.translations_configuration
+        end
+
+        def translation_record
+          @translation_record ||= Lolita::Translation::Record.new(self, translations_configuration)
+        end
+
+        def original_locale
+          translation_record.default_locale
+        end
+
+        def original_locale=(value)
+          translation_record.default_locale = value
+        end
+
+        def build_nested_translations
+          translation_record.build_nested_translations
+        end
+
+        def in(locale,&block)
+          translation_record.in(locale,&block) 
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/lolita-translation/rails.rb

@@ -2,40 +2,15 @@ module LolitaTranslation
   class Engine < Rails::Engine
 
   end
-end
-
-Lolita::Hooks.component(:"/lolita/configuration/tab/form").before do
-  tab = self.component_locals[:tab]
-  if Lolita::Translation.translatable?(tab)
-    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 Lolita::Translation.translatable?(tab)
-    self.render_component Lolita::Translation.create_translations_nested_form(self.resource,tab)
-  end
-end
+  class Railtie < Rails::Railtie
+    railtie_name :lolita_translation
 
-Lolita::Hooks.component(:"/lolita/configuration/tab/fields").around do
-  tab = self.component_locals[:tab]
-  if Lolita::Translation.translatable?(tab)
-    self.send(:render_component,"lolita/translation",:language_wrap,:tab => tab, :content => let_content)
-  else
-    let_content
+    rake_tasks do
+      load "tasks/lolita_translation.rake"
+    end
   end
-end
 
-Lolita::Hooks.component(:"/lolita/configuration/nested_form/fields").around do
-  tab = self.component_locals[:nested_form].parent
-  if Lolita::Translation.translatable?(tab)
-    self.send(:render_component,"lolita/translation",:language_wrap, :tab => tab, :content => let_content)
-  else
-    let_content
-  end
 end
 
-Lolita::Hooks.component(:"/lolita/configuration/tabs/display").before do
-  self.render_component "lolita/translation", :assets
-end
+require 'lolita-translation/lolita/component_hooks.rb'

data/lib/lolita-translation/record.rb

@@ -0,0 +1,220 @@
+require 'i18n'
+require 'lolita-translation/translated_string'
+require 'lolita-translation/utils'
+
+module Lolita
+  module Translation
+
+    class Record
+      class AbstractRecord
+        attr_reader :orm_record
+
+        def initialize(orm_record,configuration = nil)
+          @configuration  = configuration
+          @orm_record     = orm_record
+        end
+
+        def default_locale=(value)
+          nil
+        end
+
+        def locale
+          system_current_locale
+        end
+
+        def attribute name
+          nil
+        end
+
+        def translated_attribute name, options = {}
+          nil
+        end
+
+        def new_record?
+          nil
+        end
+
+        def association_key
+          nil
+        end
+
+        def has_translation_for?(locale)
+          nil
+        end
+    
+        private
+
+        def adapter
+          Lolita::DBI::Base.create(orm_record.class)
+        end
+
+        def system_current_locale
+          ::I18n.locale
+        end
+
+        def system_default_locale
+          ::I18n.default_locale
+        end
+
+        def locale_field
+          @configuration && @configuration.locale_field_name.to_s
+        end
+
+        def translation_string(str,attr_name)
+          TranslatedString.new(str.to_s, self, attr_name)
+        end
+
+        def association_name
+          @configuration && @configuration.association_name
+        end
+
+      end
+
+      class ARRecord < AbstractRecord
+        def default_locale=(value)
+          if has_locale_column?
+            orm_record.send(:"#{locale_field}=",value)
+          else
+            super
+          end
+        end
+
+        def locale
+          if has_locale_column? 
+            if value = orm_record.attributes[locale_field] and value.to_s.size > 0
+              value
+            else
+              super
+            end
+          else
+            system_default_locale
+          end  
+        end
+
+        def attribute(name)
+          translation_string(orm_record.attributes[name.to_s],name)
+        end
+
+        def translated_attribute(name, options = {})
+          translation_record = find_translation_by_locale(options[:locale])
+          if translation_record and str = translation_string(translation_record.attributes[name.to_s],name) and str.size > 0
+            str
+          else
+            attribute(name)
+          end
+        end
+
+        def new_reocrd?
+          orm_record.new_record?
+        end
+
+        def association_key
+          association = adapter.reflect_on_association(association_name)
+          association.key
+        end
+
+        def has_translation_for?(locale)
+          !!find_translation_by_locale(locale)
+        end
+
+        private
+
+        def has_locale_column?
+          orm_record.class.column_names.include?(locale_field)
+        end
+
+        def translations
+          orm_record.translations
+        end
+
+        def find_translation_by_locale given_locale
+          translations.detect{|translation| 
+            translation.locale.to_s == given_locale.to_s
+          }
+        end
+      end
+
+      class MongoidRecord < AbstractRecord
+        
+      end
+
+      attr_reader :original_record, :default_locale, :orm_wrapper
+
+      def initialize(original_record, configuration = nil)
+        @configuration          = configuration
+        @original_record        = original_record
+        @orm_wrapper            = get_orm_wrapper
+        @default_locale         = @orm_wrapper.locale
+        @record_current_locale  = nil
+      end
+
+      def attribute(name)
+        if default_locale.to_s == current_locale.to_s
+          @orm_wrapper.attribute(name)
+        else
+          @orm_wrapper.translated_attribute(name, :locale => current_locale)
+        end
+      end
+
+      def build_nested_translations
+        available_locales.each do |locale|
+          unless self.default_locale.to_s == locale.to_s 
+            attributes = { :locale => locale.to_s }
+            original_record.translations.build(attributes) unless orm_wrapper.has_translation_for?(locale)
+          end
+        end
+      end
+
+      def default_locale=(value)
+        @orm_wrapper.default_locale = value
+      end 
+
+      def in(locale)
+        old_locale = @record_current_locale
+        @record_current_locale = locale
+        if block_given?
+          yield
+          @record_current_locale = old_locale
+        end
+      end
+
+      def system_current_locale
+        ::I18n.locale
+      end
+      
+      private
+
+      def available_locales
+        ::I18n.available_locales
+      end
+
+      def current_locale
+        @record_current_locale || system_current_locale
+      end
+
+      def get_orm_wrapper
+        if is_active_record?
+          ARRecord.new(original_record,@configuration)
+        elsif is_mongoid_record?
+          MongoidRecord.new(original_record,@configuration)
+        else
+          AbstractRecord.new(original_record,@configuration)
+        end 
+      end
+
+      def is_mongoid_record?
+        Lolita::Translation::Utils.mongoid_class?(original_class)
+      end
+
+      def is_active_record?
+        Lolita::Translation::Utils.active_record_class?(original_class)
+      end
+
+      def original_class
+        original_record.class
+      end
+
+    end
+
+  end
+end