awesome_translations 0.0.24 → 0.0.25

data/lib/awesome_translations/cache_database_generator/handler_translation.rb

@@ -0,0 +1,43 @@
+class AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation < BazaModels::Model
+  belongs_to :group, foreign_key: "group_id", class_name: "AwesomeTranslations::CacheDatabaseGenerator::Group"
+  belongs_to :handler, foreign_key: "handler_id", class_name: "AwesomeTranslations::CacheDatabaseGenerator::Handler"
+  belongs_to :translation_key, foreign_key: "translation_key_id", class_name: "AwesomeTranslations::CacheDatabaseGenerator::TranslationKey"
+
+  validates_presence_of :handler, :translation_key
+
+  delegate :key, :last_key, to: :translation_key
+  delegate :value, to: :translation, prefix: true
+  delegate :array_translation?, :file_line_content, :file_line_content?, :translated_value_for_locale, to: :translation
+
+  def key_show_with_fallback
+    key_show.presence || last_key
+  end
+
+  def translation
+    @translation ||= AwesomeTranslations::Translation.new(
+      key: key,
+      dir: dir,
+      full_path: full_path,
+      file_path: file_path,
+      line_no: line_no
+    )
+  end
+
+  def finished?
+    @finished ||= translation.finished?
+  end
+
+  def unfinished?
+    !finished?
+  end
+
+  def array_key
+    return unless (match = key.match(/\A(.+)\[(\d+)\]\Z/))
+    match[1]
+  end
+
+  def array_no
+    return unless (match = key.match(/\A(.+)\[(\d+)\]\Z/))
+    match[2].to_i
+  end
+end

data/lib/awesome_translations/cache_database_generator/translation_key.rb

@@ -0,0 +1,13 @@
+class AwesomeTranslations::CacheDatabaseGenerator::TranslationKey < BazaModels::Model
+  belongs_to :group, foreign_key: "group_id"
+  belongs_to :handler, foreign_key: "handler_id"
+
+  has_many :handler_translations, dependent: :destroy, foreign_key: "translation_key_id", class_name: "AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation"
+  has_many :translation_values, dependent: :destroy, foreign_key: "translation_key_id", class_name: "AwesomeTranslations::CacheDatabaseGenerator::TranslationValue"
+
+  validates_presence_of :group, :handler
+
+  def last_key
+    key.to_s.split('.').last
+  end
+end

data/lib/awesome_translations/cache_database_generator/translation_value.rb

@@ -0,0 +1,24 @@
+class AwesomeTranslations::CacheDatabaseGenerator::TranslationValue < BazaModels::Model
+  belongs_to :translation_key, foreign_key: "translation_key_id", class_name: "AwesomeTranslations::CacheDatabaseGenerator::TranslationKey"
+
+  validates_presence_of :translation_key
+
+  delegate :key, to: :translation_key
+
+  def calculated_translation_file_path
+    "#{handler_translation.dir}/#{locale}.yml"
+  end
+
+  def handler_translation
+    @handler_translation ||= AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation
+      .find_by(translation_key_id: translation_key_id)
+  end
+
+  def migrate_to_awesome_translations_namespace!
+    AwesomeTranslations::TranslationMigrator.new(
+      translation_key: translation_key,
+      handler_translation: handler_translation,
+      translation_value: self
+    ).execute
+  end
+end

data/lib/awesome_translations/cache_database_generator.rb

@@ -0,0 +1,266 @@
+class AwesomeTranslations::CacheDatabaseGenerator
+  AutoAutoloader.autoload_sub_classes(self, __FILE__)
+
+  attr_reader :db
+
+  def self.current
+    @current ||= AwesomeTranslations::CacheDatabaseGenerator.new
+  end
+
+  def initialize(args = {})
+    require "baza"
+
+    @args = args
+    @debug = @args[:debug] || false
+
+    init_database
+    execute_migrations
+  end
+
+  def init_database
+    @initialized = true
+    @db = Baza::Db.new(type: :sqlite3, path: database_path, debug: false)
+
+    AwesomeTranslations::CacheDatabaseGenerator::Group.db = @db
+    AwesomeTranslations::CacheDatabaseGenerator::Group.table_name = "groups"
+
+    AwesomeTranslations::CacheDatabaseGenerator::Handler.db = @db
+    AwesomeTranslations::CacheDatabaseGenerator::Handler.table_name = "handlers"
+
+    AwesomeTranslations::CacheDatabaseGenerator::TranslationKey.db = @db
+    AwesomeTranslations::CacheDatabaseGenerator::TranslationKey.table_name = "translation_keys"
+
+    AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation.db = @db
+    AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation.table_name = "handler_translations"
+
+    AwesomeTranslations::CacheDatabaseGenerator::TranslationValue.db = @db
+    AwesomeTranslations::CacheDatabaseGenerator::TranslationValue.table_name = "translation_values"
+  end
+
+  def close
+    @initialized = false
+
+    @db.close if @db
+    @db = nil
+
+    AwesomeTranslations::CacheDatabaseGenerator::Group.db = nil
+    AwesomeTranslations::CacheDatabaseGenerator::Handler.db = nil
+    AwesomeTranslations::CacheDatabaseGenerator::TranslationKey.db = nil
+    AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation.db = nil
+    AwesomeTranslations::CacheDatabaseGenerator::TranslationValue.db = nil
+  end
+
+  def cache_translations
+    cache_yml_translations
+    cache_handler_translations
+
+    clean_up_not_found
+  end
+
+  def with_transactioner
+    require "active-record-transactioner"
+
+    ActiveRecordTransactioner.new do |transactioner|
+      @transactioner = transactioner
+      yield
+    end
+  end
+
+  def cache_yml_translations
+    cache_translations_in_dir(Rails.root.join("config", "locales"))
+  end
+
+  def cache_handler_translations
+    cache_translations_in_handlers
+  end
+
+  def initialized?
+    @initialized ||= false
+  end
+
+  def self.database_path
+    @database_path ||= Rails.root.join("db", "awesome_translations.sqlite3").to_s
+  end
+
+  def database_path
+    @database_path ||= self.class.database_path
+  end
+
+  def update_handlers
+    @handlers_found ||= {}
+
+    AwesomeTranslations::Handler.all.each do |handler|
+      handler_model = AwesomeTranslations::CacheDatabaseGenerator::Handler.find_or_initialize_by(identifier: handler.id)
+      handler_model.assign_attributes(name: handler.name)
+      handler_model.save!
+
+      @handlers_found[handler_model.id] = true
+
+      yield handler, handler_model if block_given?
+    end
+  end
+
+  def update_groups_for_handler(handler, handler_model)
+    @groups_found ||= {}
+
+    handler.groups.each do |group|
+      group_model = AwesomeTranslations::CacheDatabaseGenerator::Group.find_or_initialize_by(
+        handler_id: handler_model.id,
+        identifier: group.id
+      )
+      group_model.assign_attributes(name: group.name)
+      group_model.save!
+
+      @groups_found[group_model.id] = true
+
+      yield group, group_model if block_given?
+    end
+  end
+
+  def update_translations_for_group(handler_model, group, group_model)
+    @translation_keys_found ||= {}
+    @handler_translations_found ||= {}
+
+    group.translations.each do |translation|
+      translation_key = AwesomeTranslations::CacheDatabaseGenerator::TranslationKey.find_or_initialize_by(key: translation.key)
+      translation_key.assign_attributes(group_id: group_model.id, handler_id: handler_model.id)
+      translation_key.save!
+
+      raise "KEY ERROR: #{translation_key.inspect}" unless translation_key.id.to_i > 0
+
+      @translation_keys_found[translation_key.id] = true
+
+      handler_translation = AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation.find_or_initialize_by(
+        translation_key_id: translation_key.id,
+        handler_id: handler_model.id,
+        group_id: group_model.id
+      )
+      handler_translation.assign_attributes(
+        default: translation.default,
+        file_path: translation.file_path,
+        line_no: translation.line_no,
+        key_show: translation.key_show,
+        full_path: translation.full_path,
+        dir: translation.dir
+      )
+
+      if @transactioner && handler_translation.persisted?
+        @transactioner.save!(handler_translation)
+      else
+        handler_translation.save!
+      end
+
+      @handler_translations_found[handler_translation.id] = true
+    end
+  end
+
+private
+
+  def debug(message)
+    print "#{message}\n" if @debug
+  end
+
+  def execute_migrations
+    require "baza_migrations"
+
+    executor = BazaMigrations::MigrationsExecutor.new(db: @db)
+    executor.add_dir "#{File.dirname(__FILE__)}/../../db/baza_translations_migrations"
+    executor.execute_migrations
+  end
+
+  def cache_translations_in_handlers
+    with_transactioner do
+      update_handlers do |handler, handler_model|
+        update_groups_for_handler(handler, handler_model) do |group, group_model|
+          update_translations_for_group(handler_model, group, group_model)
+        end
+      end
+    end
+  end
+
+  def cache_translations_in_dir(dir_path)
+    debug "Looking for translations in #{dir_path}"
+    @translation_values_found ||= {}
+
+    Dir.foreach(dir_path) do |file|
+      next if file == "." || file == ".."
+
+      full_path = "#{dir_path}/#{file}"
+
+      if File.directory?(full_path)
+        cache_translations_in_dir(full_path)
+      elsif File.extname(full_path) == ".yml"
+        cache_translations_in_file(full_path)
+      end
+    end
+  end
+
+  def cache_translations_in_file(file_path)
+    @translation_keys_found ||= {}
+
+    debug "Cache translations in #{file_path}"
+
+    i18n_hash = YAML.load_file(file_path)
+    debug "Hash: #{i18n_hash}"
+
+    i18n_hash.each do |locale, translations|
+      cache_translations_in_hash(file_path, locale, translations)
+    end
+  end
+
+  def cache_translations_in_hash(file_path, locale, i18n_hash, keys = [])
+    i18n_hash.each do |key, value|
+      current_key = keys.clone
+      current_key << key
+
+      if value.is_a?(Hash)
+        debug "Found new hash: #{current_key.join(".")}"
+        cache_translations_in_hash(file_path, locale, value, current_key)
+      else
+        debug "Found new key: #{current_key.join(".")} translated to #{value}"
+
+        key = current_key.join(".")
+
+        translation_key = AwesomeTranslations::CacheDatabaseGenerator::TranslationKey.find_or_create_by!(key: key)
+        @translation_keys_found[translation_key.id] = true
+        raise "KEY ERROR: #{translation_key.inspect}" unless translation_key.id.to_i > 0
+
+        translation_value = AwesomeTranslations::CacheDatabaseGenerator::TranslationValue.find_or_initialize_by(
+          translation_key_id: translation_key.id,
+          locale: locale
+        )
+        translation_value.assign_attributes(
+          file_path: file_path,
+          value: value
+        )
+        translation_value.save!
+
+        @translation_values_found[translation_value.id] = true
+      end
+    end
+  end
+
+  def clean_up_not_found
+    @db.transaction do
+      AwesomeTranslations::CacheDatabaseGenerator::Handler
+        .where.not(id: @handlers_found.keys)
+        .destroy_all
+
+      AwesomeTranslations::CacheDatabaseGenerator::HandlerTranslation
+        .where.not(id: @handler_translations_found.keys)
+        .destroy_all
+
+      AwesomeTranslations::CacheDatabaseGenerator::Group
+        .where.not(id: @groups_found.keys)
+        .destroy_all
+
+      AwesomeTranslations::CacheDatabaseGenerator::TranslationKey
+        .where.not(id: @translation_keys_found.keys)
+        .destroy_all
+
+      AwesomeTranslations::CacheDatabaseGenerator::TranslationValue
+        .where.not(id: @translation_values_found.keys)
+        .destroy_all
+    end
+  end
+end

data/lib/awesome_translations/engine.rb

@@ -1,3 +1,7 @@
+require "haml-rails"
+require "sass-rails"
+require "jquery-rails"
+
 class AwesomeTranslations::Engine < ::Rails::Engine
   isolate_namespace AwesomeTranslations
 end

data/lib/awesome_translations/erb_inspector.rb

@@ -1,11 +1,10 @@
 # Used to find translations in the Rails app by inspecting .erb- and .haml-files.
 class AwesomeTranslations::ErbInspector
-  autoload :FileInspector, "#{File.dirname(__FILE__)}/erb_inspector/file_inspector"
-  autoload :TranslationInspector, "#{File.dirname(__FILE__)}/erb_inspector/translation_inspector"
+  AutoAutoloader.autoload_sub_classes(self, __FILE__)
 
   def initialize(args = {})
     @args = args
-    @args[:exts] ||= [".erb", ".haml", ".rb"]
+    @args[:exts] ||= [".erb", ".haml", ".rb", ".rake"]
 
     if @args[:dirs]
       @dirs = @args[:dirs]

data/lib/awesome_translations/handlers/erb_handler.rb

@@ -5,8 +5,10 @@ class AwesomeTranslations::Handlers::ErbHandler < AwesomeTranslations::Handlers:
   def groups
     ArrayEnumerator.new do |yielder|
       erb_inspector.files.each do |file|
-        yielder << AwesomeTranslations::Group.new(
-          id: Base64.urlsafe_encode64(file.full_path),
+        id = file.file_path.gsub(/[^A-z0-9]/, "_")
+
+        group = AwesomeTranslations::Group.new(
+          id: id,
           handler: self,
           data: {
             name: file.file_path,
@@ -15,6 +17,8 @@ class AwesomeTranslations::Handlers::ErbHandler < AwesomeTranslations::Handlers:
             file_path: file.file_path
           }
         )
+
+        yielder << group if translations_for_group(group).any?
       end
     end
   end
@@ -22,7 +26,7 @@ class AwesomeTranslations::Handlers::ErbHandler < AwesomeTranslations::Handlers:
   def translations_for_group(group)
     ArrayEnumerator.new do |yielder|
       # Parse views for translations.
-      file = erb_inspector.file(group.data[:root_path], group.data[:file_path])
+      file = erb_inspector.file(group.data.fetch(:root_path), group.data.fetch(:file_path))
       file.translations.each do |translation|
         next if translation.global?
         yielder << translation.model

data/lib/awesome_translations/handlers/library_handler.rb

@@ -2,8 +2,10 @@ class AwesomeTranslations::Handlers::LibraryHandler < AwesomeTranslations::Handl
   def groups
     ArrayEnumerator.new do |yielder|
       erb_inspector.files.each do |file|
-        yielder << AwesomeTranslations::Group.new(
-          id: Base64.urlsafe_encode64(file.full_path),
+        id = file.file_path.gsub(/[^A-z0-9]/, "_")
+
+        group = AwesomeTranslations::Group.new(
+          id: id,
           handler: self,
           data: {
             name: file.file_path,
@@ -12,6 +14,8 @@ class AwesomeTranslations::Handlers::LibraryHandler < AwesomeTranslations::Handl
             file_path: file.file_path
           }
         )
+
+        yielder << group if translations_for_group(group).any?
       end
     end
   end
@@ -31,7 +35,7 @@ private
 
   def erb_inspector
     @erb_inspector ||= AwesomeTranslations::ErbInspector.new(
-      exts: ['.rb']
+      exts: ['.rb', '.rake']
     )
   end
 end

data/lib/awesome_translations/handlers/model_handler.rb

@@ -20,6 +20,7 @@ class AwesomeTranslations::Handlers::ModelHandler < AwesomeTranslations::Handler
       paperclip_attachments(model_inspector).each { |translation| yielder << translation }
       relationships(model_inspector).each { |translation| yielder << translation }
       monetized_attributes(model_inspector).each { |translation| yielder << translation }
+      globalize_attributes(model_inspector).each { |translation| yielder << translation }
     end
   end
 
@@ -106,4 +107,17 @@ private
 
     return result
   end
+
+  def globalize_attributes(model_inspector)
+    result = []
+
+    model_inspector.globalize_attributes do |name|
+      result << AwesomeTranslations::Translation.new(
+        key: model_inspector.attribute_key(name),
+        dir: dir_path(model_inspector)
+      )
+    end
+
+    return result
+  end
 end

data/lib/awesome_translations/handlers.rb

@@ -1,27 +1,28 @@
 class AwesomeTranslations::Handlers
-  @handlers = []
+  AutoAutoloader.autoload_sub_classes(self, __FILE__)
 
-  Dir.foreach("#{File.dirname(__FILE__)}/handlers") do |file|
-    match = file.match(/\A(.+)_handler\.rb\Z/)
-    next unless match
+  def self.list
+    unless @handlers
+      @handlers = []
 
-    const_name_snake = "#{match[1]}_handler"
-    const_name_camel = StringCases.snake_to_camel(const_name_snake)
+      Dir.foreach("#{File.dirname(__FILE__)}/handlers") do |file|
+        match = file.match(/\A(.+)_handler\.rb\Z/)
+        next unless match
 
-    autoload const_name_camel.to_sym, "#{File.dirname(__FILE__)}/handlers/#{const_name_snake}"
+        const_name_snake = "#{match[1]}_handler"
+        next if const_name_snake == "base_handler"
+        const_name_camel = StringCases.snake_to_camel(const_name_snake)
 
-    unless const_name_snake == "base_handler"
-      @handlers << AwesomeTranslations::Handler.new(
-        id: const_name_snake,
-        const_name: const_name_camel,
-        name: const_name_camel
-      )
-    end
-  end
+        handler = AwesomeTranslations::Handler.new(
+          id: const_name_snake,
+          const_name: const_name_camel,
+          name: const_name_camel
+        )
 
-  @handlers = @handlers.select { |handler| handler.instance.enabled? }
+        @handlers << handler if handler.instance.enabled?
+      end
+    end
 
-  def self.list
     @handlers
   end
 end

data/lib/awesome_translations/model_inspector.rb

@@ -15,7 +15,7 @@ class AwesomeTranslations::ModelInspector
 
     ArrayEnumerator.new do |yielder|
       find_subclasses(ActiveRecord::Base) do |model_inspector|
-        next if @skip.include? model_inspector.clazz.name
+        next if !model_inspector.clazz.name || @skip.include?(model_inspector.clazz.name)
         yielder << model_inspector
       end
     end
@@ -48,6 +48,14 @@ class AwesomeTranslations::ModelInspector
     end
   end
 
+  def globalize_attributes
+    return if !::Kernel.const_defined?('Globalize') || !@clazz.respond_to?(:translated_attribute_names)
+
+    @clazz.translated_attribute_names.each do |attribute|
+      yield attribute.to_s
+    end
+  end
+
   def snake_name
     clazz.name.gsub("::", "/").split("/").map { |part| ::StringCases.camel_to_snake(part) }.join("/")
   end

data/lib/awesome_translations/translation_migrator.rb

@@ -0,0 +1,94 @@
+# Transfers manual made translations also found in handlers over into the AwesomeTranslations namespace
+class AwesomeTranslations::TranslationMigrator
+  def initialize(args)
+    require "fileutils"
+
+    @handler_translation = args.fetch(:handler_translation)
+    @translation_value = args.fetch(:translation_value)
+    @translation_key = @handler_translation.translation_key
+
+    @key_parts = @translation_key.key.split(".")
+
+    @locale = @translation_value.locale
+
+    @old_path = @translation_value.file_path
+    @new_path = "#{@handler_translation.dir}/#{@translation_value.locale}.yml"
+  end
+
+  def execute
+    remove_from_old_file
+  end
+
+private
+
+  def remove_from_old_file
+    translations_hash = YAML.load_file(@old_path)
+
+    new_translations_hash = YAML.load_file(@new_path) if File.exist?(@new_path)
+    new_translations_hash ||= {}
+    new_translations_hash[@locale] ||= {}
+
+    pointer = translations_hash.fetch(@locale)
+
+    transfer_from_old_hash_to_new(
+      new_translations_hash.fetch(@locale),
+      @key_parts.clone,
+      pointer
+    )
+
+    clean_empty_hash(translations_hash)
+
+    FileUtils.mkdir_p(File.dirname(@new_path))
+    File.open(@new_path, "w") { |fp| fp.write(YAML.dump(new_translations_hash)) }
+
+    if translations_hash.empty?
+      I18n.load_path.delete(@old_path)
+      File.unlink(@old_path)
+    else
+      File.open(@old_path, "w") { |fp| fp.write(YAML.dump(translations_hash)) }
+    end
+
+    @translation_value.update_attributes!(file_path: @new_path)
+  end
+
+  def transfer_from_old_hash_to_new(new_hash, current_parts, current_pointer)
+    new_part = current_parts.shift
+    new_pointer = current_pointer.fetch(new_part)
+
+    if current_parts.empty?
+      new_hash[new_part] = current_pointer.delete(new_part)
+    else
+      new_hash[new_part] ||= {}
+    end
+
+    if new_pointer.is_a?(Hash)
+      transfer_from_old_hash_to_new(
+        new_hash.fetch(new_part),
+        current_parts,
+        new_pointer
+      )
+    end
+  end
+
+  # Cleans out empty keys, if they don't contain translations
+  def clean_empty_hash(hash)
+    all_empty = true
+
+    hash.delete_if do |key, value|
+      next unless value.is_a?(Hash)
+
+      if value.empty?
+        true
+      else
+        clean_empty_hash(value)
+
+        if value.empty?
+          true
+        else
+          all_empty = false
+          false
+        end
+      end
+    end
+  end
+end

data/lib/awesome_translations/version.rb

@@ -1,3 +1,3 @@
 module AwesomeTranslations
-  VERSION = '0.0.24'
+  VERSION = '0.0.25'
 end

data/lib/awesome_translations.rb

@@ -1,17 +1,10 @@
+require "auto_autoloader"
+require "baza_models"
 require "string-cases"
 require "array_enumerator"
 
 module AwesomeTranslations
-  path = "#{File.dirname(__FILE__)}/awesome_translations"
-
-  autoload :Config, "#{path}/config"
-  autoload :ControllerTranslateFunctionality, "#{path}/controller_translate_functionality"
-  autoload :ErbInspector, "#{path}/erb_inspector"
-  autoload :GlobalTranslator, "#{path}/global_translator"
-  autoload :Handlers, "#{path}/handlers"
-  autoload :ModelInspector, "#{path}/model_inspector"
-  autoload :ObjectExtensions, "#{path}/object_extensions"
-  autoload :TranslateFunctionality, "#{path}/translate_functionality"
+  AutoAutoloader.autoload_sub_classes(self, __FILE__)
 
   def self.config
     @config ||= AwesomeTranslations::Config.new