releaf-i18n_database 0.2.1

data/app/lib/releaf/i18n_database/translations_importer.rb

@@ -0,0 +1,72 @@
+module Releaf::I18nDatabase
+  class TranslationsImporter
+    class UnsupportedFileFormatError < StandardError; end
+
+    def initialize file_path, file_extension
+      require "roo"
+      begin
+        @excel = Roo::Spreadsheet.open(file_path, file_warning: :ignore, extension: file_extension)
+        @data = []
+        @locales = []
+      rescue ArgumentError => e
+        error_string = "Don't know how to open file"
+        if e.message.match(error_string)
+          raise UnsupportedFileFormatError
+        else
+          raise
+        end
+      end
+    end
+
+    def parsed_output
+      @excel.each_with_pagename do |name, sheet|
+        detect_sheet_locales(sheet)
+        parse_sheet(sheet)
+      end
+
+      @data
+    end
+
+    def detect_sheet_locales sheet
+      sheet.row(1).each_with_index do |cell, i|
+        if i > 0
+          @locales << cell
+        end
+      end
+    end
+
+    def parse_sheet sheet
+      (2..sheet.last_row).each do |row_no|
+        key = sheet.row(row_no)[0]
+        localizations = sheet.row(row_no)[1..-1]
+        if key.present?
+          @data << load_translation(key, localizations)
+        end
+      end
+    end
+
+    def load_translation key, localizations
+      translation = Translation.where(key: key).first_or_initialize
+      translation.key = key
+
+      localizations.each_with_index do |localization, i|
+        load_translation_data(translation, @locales[i], localization)
+      end
+
+      translation
+    end
+
+    def load_translation_data translation, locale, localization
+      translation_data = translation.translation_data.find{ |x| x.lang == locale }
+      value = localization.nil? ? '' : localization
+
+      # replace existing locale value only if new one is not blank
+      if translation_data && !value.blank?
+        translation_data.localization = value
+      # always assign value for new locale
+      elsif translation_data.nil?
+        translation_data = translation.translation_data.build(lang: locale, localization: value)
+      end
+    end
+  end
+end

data/app/lib/releaf/i18n_database/translations_utilities.rb

@@ -0,0 +1,66 @@
+module Releaf::I18nDatabase
+  class TranslationsUtilities
+
+    def self.search(collection, search_string, only_blank)
+      collection = filter_by_text(collection, search_string) if search_string.present?
+      collection = filter_only_blank_translations(collection) if only_blank == true
+      collection
+    end
+
+    def self.filter_only_blank_translations(collection)
+      blank_where_collection = Releaf::I18nDatabase::Translation
+      search_columns.each do |column|
+        blank_where_collection = blank_where_collection.where(column.eq('').or(column.eq(nil)))
+      end
+
+      collection.where(blank_where_collection.where_values.reduce(:or))
+    end
+
+    def self.filter_by_text(collection, lookup_string)
+      sql = column_searches(lookup_string).map{|column_search| "(#{column_search})" }.join(' OR ')
+      collection.where(sql)
+    end
+
+    def self.column_searches(lookup_string)
+      search_columns.map do |column|
+        lookup_string.split(' ').map do |part|
+          column.matches("%#{escape_search_string(part)}%")
+        end.inject(&:and).to_sql
+      end
+    end
+
+    def self.search_columns
+      [Releaf::I18nDatabase::Translation.arel_table[:key]] + locale_tables.map{|locale, table| table[:localization] }
+    end
+
+    def self.escape_search_string(string)
+      string.gsub(/([%|_])/){|r| "\\#{r}" }
+    end
+
+    def self.locale_tables
+      Releaf.application.config.all_locales.inject({}) do|h, locale|
+        h.update(locale => Releaf::I18nDatabase::TranslationData.arel_table.alias("#{locale}_data"))
+      end
+    end
+
+    def self.include_localizations(collection)
+      collection.select(localization_include_selects).joins(localization_include_joins)
+    end
+
+    def self.localization_include_joins
+      locale_tables.map do |locale, table|
+        "LEFT JOIN #{table.relation.name} AS #{table.name} ON #{locale}_data.translation_id = releaf_translations.id AND #{locale}_data.lang = '#{locale}'"
+      end
+    end
+
+    def self.localization_include_selects
+      (['releaf_translations.*'] + localization_include_locales_columns).join(', ')
+    end
+
+    def self.localization_include_locales_columns
+      locale_tables.map do |locale, table|
+        ["#{table.name}.localization AS #{locale}_localization", "#{table.name}.id AS #{locale}_localization_id"]
+      end.flatten
+    end
+  end
+end

data/app/models/releaf/i18n_database/translation.rb

@@ -0,0 +1,17 @@
+module Releaf::I18nDatabase
+  class Translation < ActiveRecord::Base
+    self.table_name = "releaf_translations"
+
+    validates_presence_of :key
+    validates_uniqueness_of :key
+    validates_length_of :key, maximum: 255
+
+    has_many :translation_data, dependent: :destroy, class_name: 'Releaf::I18nDatabase::TranslationData', inverse_of: :translation
+    accepts_nested_attributes_for :translation_data, allow_destroy: true
+
+    def locale_value(locale)
+      # search against all values to cache
+      translation_data.find{ |x| x.lang == locale.to_s }.try(:localization)
+    end
+  end
+end

data/app/models/releaf/i18n_database/translation_data.rb

@@ -0,0 +1,11 @@
+module Releaf::I18nDatabase
+  class TranslationData < ActiveRecord::Base
+    self.table_name = "releaf_translation_data"
+
+    validates_presence_of :translation, :lang
+    validates_uniqueness_of :translation_id, :scope => :lang
+    validates_length_of :lang, maximum: 5
+
+    belongs_to :translation, :inverse_of => :translation_data
+  end
+end

data/app/views/releaf/i18n_database/translations/_form_fields.haml

@@ -0,0 +1,40 @@
+- if @import
+  = hidden_field_tag :import, "true"
+- attributes_scope = "activerecord.attributes.#{resource_class.name.underscore}"
+- locales = Releaf.application.config.all_locales
+- @translation_ids_to_destroy ||= []
+
+- template_html = capture do
+  %tr.item{ data: { name: :translations }, style: 'display:none' }
+    %td.translation-name
+      .wrap
+        %input{type: "text", class: "text", name: "translations[][key]"}
+    - locales.each_with_index do |locale, j|
+      %td.translationCell{data: {locale: locale}}
+        %input{type: "text", class: "text", name: "translations[][localizations][#{locale}]"}
+    %td.delete-column.only-icon
+      = releaf_button(nil, "times", class: %w(danger remove-nested-item), title: t("Remove item", scope: controller_scope_name))
+%section.nested{data: {name: "translations", releaf: {template: html_escape(template_html)}}}
+  %table.table
+    %thead
+      %tr
+        %th.code= t("key", scope: attributes_scope)
+        - locales.each do |locale|
+          %th{"data-locale" => locale}
+            %span.name= builder.translate_locale(locale)
+        %th.delete
+    %tbody#variables.list
+      - @collection.each_with_index do |translation, index|
+        - @translation_ids_to_destroy << translation.id
+        %tr.item{ id: "translation_#{translation.id}", data: { name: :translations, index: index } }
+          %td.translation-name{title: translation.key}
+            .wrap
+              %input{type: "text", class: "text", name: "translations[][key]", value: translation.key }
+          - locales.each_with_index do |locale, j|
+            %td.translationCell{data: {locale: locale}}
+              %input{type: "text", class: "text", name: "translations[][localizations][#{locale}]", value: translation.locale_value(locale) }
+          %td.delete-column.only-icon
+            = releaf_button(nil, "times", class: %w(danger remove-nested-item), title: t("Remove item", scope: controller_scope_name))
+  %div.tools
+    = releaf_button(t('Add item', :scope => 'admin.releaf_translations'), "plus", class: "add-nested-item")
+= hidden_field_tag :existing_translations, @translation_ids_to_destroy.join(",")

data/app/views/releaf/i18n_database/translations/export.xlsx.axlsx

@@ -0,0 +1,24 @@
+wb = xlsx_package.workbook
+wb.use_autowidth = true
+header = wb.styles.add_style b: true
+wb.add_worksheet(name: "localization") do |sheet|
+locales = Releaf.application.config.all_locales
+
+  sheet.add_row [''] + locales, style: header
+
+  cell_styles = [nil] * (locales.size + 1)
+  cell_types =  [:string] * (locales.size + 1)
+
+  if @collection.present?
+    @collection.each do |translation|
+      columns = [translation.key]
+      locales.each do|locale|
+        columns << translation.locale_value(locale)
+      end
+
+      sheet.add_row columns, style: cell_styles, types: cell_types
+    end
+  end
+end
+
+# vim: set ft=ruby:

data/lib/releaf-i18n_database.rb

@@ -0,0 +1,5 @@
+require 'twitter_cldr'
+require 'i18n'
+require 'releaf/i18n_database/engine'
+require 'releaf/i18n_database/humanize_missing_translations'
+require 'releaf/i18n_database/backend'

data/lib/releaf/i18n_database/backend.rb

@@ -0,0 +1,169 @@
+require 'i18n/backend/base'
+# TODO convert to arel
+module Releaf
+  module I18nDatabase
+    class Backend
+      include ::I18n::Backend::Base, ::I18n::Backend::Flatten
+      CACHE = {updated_at: nil, translations: {}, missing: {}}
+      UPDATED_AT_KEY = 'releaf.i18n_database.translations.updated_at'
+
+      def reload_cache
+        CACHE[:translations] = translations || {}
+        CACHE[:missing] = {}
+        CACHE[:updated_at] = self.class.translations_updated_at
+      end
+
+      def reload_cache?
+        CACHE[:updated_at] != self.class.translations_updated_at
+      end
+
+      def self.translations_updated_at
+        Releaf::Settings[UPDATED_AT_KEY]
+      end
+
+      def self.translations_updated_at= value
+        Releaf::Settings[UPDATED_AT_KEY] = value
+      end
+
+      def store_translations locale, data, options = {}
+        new_hash = {}
+        new_hash[locale] = data
+
+        CACHE[:translations].deep_merge!(new_hash)
+        CACHE[:missing] = {}
+      end
+
+      protected
+
+      # Return all non-empty localizations
+      def localization_data
+        TranslationData.where("localization <> ''").
+          joins("LEFT JOIN releaf_translations ON releaf_translations.id = translation_id").
+          pluck("LOWER(CONCAT(lang, '.', releaf_translations.key)) AS translation_key", "localization").
+          to_h
+      end
+
+      # Return translation hash for each releaf locales
+      def translations
+        localization_cache = localization_data
+
+        Translation.order(:key).pluck("LOWER(releaf_translations.key)").map do |translation_key|
+          key_hash(translation_key, localization_cache)
+        end.inject(&:deep_merge)
+      end
+
+      def cache_lookup keys, locale, options, first_lookup
+        result = keys.inject(CACHE[:translations]) { |h, key| h.is_a?(Hash) && h.try(:[], key.downcase.to_sym) }
+
+        # when non-first match, non-pluralized and hash - return nil
+        if !first_lookup && result.is_a?(Hash) && !options.has_key?(:count)
+          result = nil
+        # return nil as we don't have valid pluralized translation
+        elsif result.is_a?(Hash) && options.has_key?(:count) && !valid_pluralized_result?(result, locale, options[:count])
+          result = nil
+        end
+
+        result
+      end
+
+      def valid_pluralized_result? result, locale, count
+        valid = false
+
+        if TwitterCldr.supported_locale?(locale)
+          rule = TwitterCldr::Formatters::Plurals::Rules.rule_for(count, locale)
+          valid = result.has_key? rule
+        end
+
+        valid
+      end
+
+      # Lookup translation from database
+      def lookup(locale, key, scope = [], options = {})
+        # reload cache if cache timestamp differs from last translations update
+        reload_cache if reload_cache?
+
+        key = normalize_flat_keys(locale, key, scope, options[:separator])
+        locale_key = "#{locale}.#{key}"
+
+        # do not process further if key already marked as missing
+        return nil if CACHE[:missing].has_key? locale_key
+
+        chain = locale_key.split('.')
+        chain_initial_length = chain.length
+        inherit_scopes = options.fetch(:inherit_scopes, true)
+
+        while (chain.length > 1) do
+          result = cache_lookup(chain, locale, options, chain_initial_length == chain.length)
+          return result if result.present?
+          break if inherit_scopes == false
+
+          # remove second last value
+          chain.delete_at(chain.length - 2)
+        end
+
+        # mark translation as missing
+        CACHE[:missing][locale_key] = true
+        create_missing_translation(locale, key, options) if create_missing_translation?(options)
+
+        return nil
+      end
+
+      def default(locale, object, subject, options = {})
+        if options[:create_default] == false
+          options = options.reject { |key, value| key == :create_default }
+          options[:create_missing] = false
+        end
+        super
+      end
+
+      def get_all_pluralizations
+        keys = []
+
+        ::Releaf.application.config.all_locales.each do|locale|
+          if TwitterCldr.supported_locale? locale
+            keys += TwitterCldr::Formatters::Plurals::Rules.all_for(locale)
+          end
+        end
+
+        keys.uniq
+      end
+
+      def create_missing_translation?(options)
+        Releaf::I18nDatabase.create_missing_translations == true && options[:create_missing] != false
+      end
+
+      def create_missing_translation(locale, key, options)
+        begin
+          if options.has_key?(:count) && options[:create_plurals] == true
+            get_all_pluralizations.each do|pluralization|
+              Translation.create(key: "#{key}.#{pluralization}")
+            end
+          else
+            Translation.create(key: key)
+          end
+        rescue ActiveRecord::RecordNotUnique
+        end
+      end
+
+      private
+
+      def key_hash key, localization_cache
+        hash = {}
+
+        ::Releaf.application.config.all_locales.each do |locale|
+          localized_key = "#{locale}.#{key}"
+          locale_hash = locale_hash(localized_key, localization_cache[localized_key])
+          hash.merge! locale_hash
+        end
+
+        hash
+      end
+
+      def locale_hash localized_key, localization
+        localized_key.to_s.split(".").reverse.inject(localization) do |value, key|
+          {key.to_sym => value}
+        end
+      end
+    end
+  end
+end

data/lib/releaf/i18n_database/builders_autoload.rb

@@ -0,0 +1,10 @@
+root_path = File.expand_path('../..', File.dirname(__dir__))
+files = %w(
+  builders_common
+  edit_builder
+  table_builder
+  index_builder
+)
+files.each do|file|
+ require "#{root_path}/app/builders/releaf/i18n_database/translations/#{file}"
+end

data/lib/releaf/i18n_database/engine.rb

@@ -0,0 +1,36 @@
+require 'axlsx_rails'
+
+module Releaf::I18nDatabase
+  require 'releaf/i18n_database/builders_autoload'
+  mattr_accessor :create_missing_translations
+  @@create_missing_translations = true
+
+  class Engine < ::Rails::Engine
+    initializer 'precompile', group: :all do |app|
+      app.config.assets.precompile += %w(releaf/controllers/releaf/i18n_database/*)
+    end
+  end
+
+  def self.components
+    [Releaf::I18nDatabase::HumanizeMissingTranslations]
+  end
+
+  def self.initialize_component
+    I18n.backend = Releaf::I18nDatabase::Backend.new
+  end
+
+  def self.draw_component_routes router
+    router.namespace :releaf, path: nil do
+      router.namespace :i18n_database, path: nil do
+        router.resources :translations, only: [:index] do
+          router.collection do
+            router.get :edit
+            router.post :update
+            router.get :export
+            router.post :import
+          end
+        end
+      end
+    end
+  end
+end