releaf-i18n_database 0.2.1 → 1.0.3

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

@@ -8,7 +8,7 @@ module Releaf::I18nDatabase
     end
 
     def self.filter_only_blank_translations(collection)
-      blank_where_collection = Releaf::I18nDatabase::Translation
+      blank_where_collection = Releaf::I18nDatabase::I18nEntry
       search_columns.each do |column|
         blank_where_collection = blank_where_collection.where(column.eq('').or(column.eq(nil)))
       end
@@ -30,7 +30,7 @@ module Releaf::I18nDatabase
     end
 
     def self.search_columns
-      [Releaf::I18nDatabase::Translation.arel_table[:key]] + locale_tables.map{|locale, table| table[:localization] }
+      [Releaf::I18nDatabase::I18nEntry.arel_table[:key]] + locale_tables.map{|_locale, table| table[:text] }
     end
 
     def self.escape_search_string(string)
@@ -39,7 +39,7 @@ module Releaf::I18nDatabase
 
     def self.locale_tables
       Releaf.application.config.all_locales.inject({}) do|h, locale|
-        h.update(locale => Releaf::I18nDatabase::TranslationData.arel_table.alias("#{locale}_data"))
+        h.update(locale => Releaf::I18nDatabase::I18nEntryTranslation.arel_table.alias("#{locale}_data"))
       end
     end
 
@@ -49,17 +49,17 @@ module Releaf::I18nDatabase
 
     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}'"
+        "LEFT JOIN #{table.relation.name} AS #{table.name} ON #{locale}_data.i18n_entry_id = releaf_i18n_entries.id AND #{locale}_data.locale = '#{locale}'"
       end
     end
 
     def self.localization_include_selects
-      (['releaf_translations.*'] + localization_include_locales_columns).join(', ')
+      (['releaf_i18n_entries.*'] + 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"]
+        ["#{table.name}.text AS #{locale}_localization", "#{table.name}.id AS #{locale}_localization_id"]
       end.flatten
     end
   end

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

@@ -0,0 +1,21 @@
+module Releaf::I18nDatabase
+  class I18nEntry < ActiveRecord::Base
+    self.table_name = "releaf_i18n_entries"
+
+    validates_presence_of :key
+    validates_uniqueness_of :key
+    validates_length_of :key, maximum: 255
+
+    has_many :i18n_entry_translation, dependent: :destroy,
+      class_name: 'Releaf::I18nDatabase::I18nEntryTranslation', inverse_of: :i18n_entry
+    accepts_nested_attributes_for :i18n_entry_translation, allow_destroy: true
+
+    def locale_value(locale)
+      find_or_initialize_translation(locale).text
+    end
+
+    def find_or_initialize_translation(locale)
+      i18n_entry_translation.find{ |translation| translation.locale == locale.to_s } || i18n_entry_translation.build(locale: locale)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Releaf::I18nDatabase
+  class I18nEntryTranslation < ActiveRecord::Base
+    self.table_name = "releaf_i18n_entry_translations"
+
+    validates_presence_of :i18n_entry, :locale
+    validates_uniqueness_of :i18n_entry_id, scope: :locale
+    validates_length_of :locale, maximum: 5
+
+    belongs_to :i18n_entry, inverse_of: :i18n_entry_translation
+  end
+end

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

@@ -13,7 +13,7 @@
       %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))
+      = releaf_button(nil, "times", class: %w(danger remove-nested-item), title: t("Remove", scope: controller_scope_name))
 %section.nested{data: {name: "translations", releaf: {template: html_escape(template_html)}}}
   %table.table
     %thead
@@ -34,7 +34,7 @@
             %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))
+            = releaf_button(nil, "times", class: %w(danger remove-nested-item), title: t("Remove", 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/lib/releaf-i18n_database.rb

@@ -1,5 +1,16 @@
+require 'axlsx_rails'
 require 'twitter_cldr'
 require 'i18n'
-require 'releaf/i18n_database/engine'
-require 'releaf/i18n_database/humanize_missing_translations'
-require 'releaf/i18n_database/backend'
+require 'roo'
+
+module Releaf::I18nDatabase
+  require 'releaf/i18n_database/engine'
+  require 'releaf/i18n_database/configuration'
+  require 'releaf/i18n_database/humanize_missing_translations'
+  require 'releaf/i18n_database/backend'
+
+  def self.components
+    [Releaf::I18nDatabase::Backend, Releaf::I18nDatabase::HumanizeMissingTranslations]
+  end
+end
+

data/lib/releaf/i18n_database/backend.rb

@@ -1,168 +1,93 @@
 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'
+      DEFAULT_CONFIG = {
+        translation_auto_creation: true,
+        translation_auto_creation_patterns: [/.*/],
+        translation_auto_creation_exclusion_patterns: [/^attributes\./]
+      }
+      attr_accessor :translations_cache
 
-      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
+      def self.initialize_component
+        I18n.backend = I18n::Backend::Chain.new(new, I18n.backend)
       end
 
-      def store_translations locale, data, options = {}
-        new_hash = {}
-        new_hash[locale] = data
-
-        CACHE[:translations].deep_merge!(new_hash)
-        CACHE[:missing] = {}
+      def self.locales_pluralizations
+        Releaf.application.config.all_locales.map do|locale|
+          TwitterCldr::Formatters::Plurals::Rules.all_for(locale) if TwitterCldr.supported_locale?(locale)
+        end.flatten.uniq.compact
       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
+      def self.configure_component
+        Releaf.application.config.add_configuration(
+          Releaf::I18nDatabase::Configuration.new(DEFAULT_CONFIG)
+        )
       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)
+      def self.reset_cache
+        backend_instance.translations_cache = nil
       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
+      def self.backend_instance
+        if I18n.backend.is_a? I18n::Backend::Chain
+          I18n.backend.backends.find{|b| b.is_a?(Releaf::I18nDatabase::Backend) }
+        elsif I18n.backend.is_a? Releaf::I18nDatabase::Backend
+          I18n.backend
         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
+      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
-
-        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)
+      def translations
+        if translations_cache && !translations_cache.expired?
+          translations_cache
+        else
+          self.translations_cache = Releaf::I18nDatabase::TranslationsStore.new
         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
+      def self.translations_updated_at
+        Releaf::Settings[UPDATED_AT_KEY]
       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
+      def self.translations_updated_at= value
+        Releaf::Settings[UPDATED_AT_KEY] = value
       end
 
-      def create_missing_translation?(options)
-        Releaf::I18nDatabase.create_missing_translations == true && options[:create_missing] != false
-      end
+      def store_translations(locale, data, options = {})
+        # pass to simple backend
 
-      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
+        I18n.backend.backends.last.store_translations(locale, data, options)
       end
 
-      private
-
-      def key_hash key, localization_cache
-        hash = {}
+      # Lookup translation from database
+      def lookup(locale, key, scope = [], options = {})
+        key = normalize_flat_keys(locale, key, scope, options[:separator])
 
-        ::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
+        return if translations.missing?(locale, key)
 
-        hash
-      end
+        result = translations.lookup(locale, key, options)
+        translations.missing(locale, key, options) if result.nil?
 
-      def locale_hash localized_key, localization
-        localized_key.to_s.split(".").reverse.inject(localization) do |value, key|
-          {key.to_sym => value}
-        end
+        result
       end
     end
   end

data/lib/releaf/i18n_database/configuration.rb

@@ -0,0 +1,8 @@
+module Releaf::I18nDatabase
+  class Configuration
+    include Virtus.model(strict: true)
+    attribute :translation_auto_creation, Boolean
+    attribute :translation_auto_creation_patterns, Array
+    attribute :translation_auto_creation_exclusion_patterns, Array
+  end
+end

data/lib/releaf/i18n_database/engine.rb

@@ -1,36 +1,7 @@
-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
+      app.config.assets.precompile += %w(controllers/releaf/i18n_database/*)
     end
   end
 end

data/lib/releaf/i18n_database/humanize_missing_translations.rb

@@ -1,7 +1,7 @@
 module Releaf::I18nDatabase
   module HumanizeMissingTranslations
     def call(exception, locale, key, options)
-      if exception.is_a?(I18n::MissingTranslation)
+      if key.present? && exception.is_a?(I18n::MissingTranslation)
         key.to_s.split('.').last.humanize
       else
         super

data/spec/builders/translations/builder_common_spec.rb

@@ -30,7 +30,7 @@ describe Releaf::I18nDatabase::Translations::BuildersCommon, type: :class do
 
   describe "#export_button" do
     it "returns export button" do
-      allow(subject).to receive(:t).with("export").and_return("exp")
+      allow(subject).to receive(:t).with("Export").and_return("exp")
       allow(subject).to receive(:action_url).with(:export, format: :xlsx).and_return("_exp_url_")
       allow(subject).to receive(:button).with("exp", "download", class: "secondary", href: "_exp_url_").and_return("btn")
       expect(subject.export_button).to eq('btn')

data/spec/builders/translations/edit_builder_spec.rb

@@ -79,8 +79,8 @@ describe Releaf::I18nDatabase::Translations::EditBuilder, type: :class do
   describe "#back_to_index_button" do
     it "returns localized value for given resource and column(locale)" do
       allow(subject).to receive(:t).with("Back to list").and_return("back")
-      allow(subject).to receive(:action_url).with(:index).and_return("index_url")
-      allow(subject).to receive(:button).with("back", "caret-left", class: "secondary", href: "index_url").and_return("index_btn")
+      allow(subject).to receive(:action_url).with(:index).and_return("index_path")
+      allow(subject).to receive(:button).with("back", "caret-left", class: "secondary", href: "index_path").and_return("index_btn")
       expect(subject.back_to_index_button).to eq("index_btn")
     end
   end

data/spec/builders/translations/table_builder_spec.rb

@@ -3,7 +3,7 @@ require "rails_helper"
 describe Releaf::I18nDatabase::Translations::TableBuilder, type: :class do
   class TableBuilderTestHelper < ActionView::Base; end
   let(:template){ TableBuilderTestHelper.new }
-  let(:resource_class){ Releaf::I18nDatabase::Translation }
+  let(:resource_class){ Releaf::I18nDatabase::I18nEntry }
   let(:subject){ described_class.new([], resource_class, template, {}) }
 
   before do

data/spec/controllers/i18n_backend/translations_controller_spec.rb

@@ -14,20 +14,16 @@ describe Releaf::I18nDatabase::TranslationsController do
   end
 
   before build_translations: true do
-    @t1 = FactoryGirl.create(:translation, key: 'test.key1')
-    @t2 = FactoryGirl.create(:translation, key: 'great.stuff')
-    @t3 = FactoryGirl.create(:translation, key: 'geek.stuff')
-
-    @t1_en = FactoryGirl.create(:translation_data, lang: 'en', localization: 'testa atslēga', translation_id: @t1.id)
-
-    @t2_en = FactoryGirl.create(:translation_data, lang: 'en', localization: 'awesome stuff', translation_id: @t2.id)
-    @t2_lv = FactoryGirl.create(:translation_data, lang: 'lv', localization: 'lieliska manta', translation_id: @t2.id)
-
-    @t3_en = FactoryGirl.create(:translation_data, lang: 'en', localization: 'geek stuff', translation_id: @t3.id)
-    @t3_lv = FactoryGirl.create(:translation_data, lang: 'lv', localization: 'nūģu lieta', translation_id: @t3.id)
+    @t1 = Releaf::I18nDatabase::I18nEntry.create(key: 'test.key1')
+    @t2 = Releaf::I18nDatabase::I18nEntry.create(key: 'great.stuff')
+    @t3 = Releaf::I18nDatabase::I18nEntry.create(key: 'geek.stuff')
+    @t1.i18n_entry_translation.create(locale: 'en', text: 'testa atslēga')
+    @t2.i18n_entry_translation.create(locale: 'en', text: 'awesome stuff')
+    @t2.i18n_entry_translation.create(locale: 'lv', text: 'lieliska manta')
+    @t3.i18n_entry_translation.create(locale: 'en', text: 'geek stuff')
+    @t3.i18n_entry_translation.create(locale: 'lv', text: 'nūģu lieta')
   end
 
-
   describe "GET #index", build_translations: true do
     context "when not searching" do
       it "renders all translations" do
@@ -124,13 +120,8 @@ describe Releaf::I18nDatabase::TranslationsController do
   describe "#import" do
     context "when file uploaded" do
       before do
-        file = fixture_file_upload(File.expand_path('../../fixtures/translations_import.xlsx', __dir__), 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
-        class << file
-          # The reader method is present in a real invocation,
-          # but missing from the fixture object for some reason (Rails 3.1.1)
-          attr_reader :tempfile
-        end
-
+        file = fixture_file_upload(File.expand_path('../../fixtures/translations_import.xlsx', __dir__),
+                                   'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
         post :import, import_file: file
       end