releaf-i18n_database 0.2.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1708060372539566d0f74c1d83d592b6052fab44
-  data.tar.gz: 26aa76b2f65753dddb9e0b85cfc3a2e4449daf30
+  metadata.gz: 9c95500c88e31844f3bb04328fae6744220abb94
+  data.tar.gz: 6bfb4f23bf7bab4f737ff2cfde0fc0055e4eb301
 SHA512:
-  metadata.gz: a1c4f3c879bdecf8b93032975e29b2b178121d51d705478bf1c3e72acf9d04eb091e001f603af442597fddef113d01e8cf71ca9ac884713096be8722ff6a39fa
-  data.tar.gz: 086aed43840796336776f6f23a09b472a90b1c0909290649bc26aa88f7a0c541e4a1a129201f3c5c4cfde52bc1cfe7bdf1a2eb04c4cb67e09dad8246c0e767d8
+  metadata.gz: 68ca2b2d9c701db9daadfabf4a80f659253ac0b2c75bac4ea3c5aad372a57c000129deeba3ed8a95590605845bc2220bd358fcb0cfe58dd627a74d166ad30443
+  data.tar.gz: bcda02afedc7bec4e3921f97603929e30c0a6b74ef675f18a55b943a41dd8fb11a4c31912dff49b5faedc15772c43d1a151b699d140bf39b44f51df6149e42f4

data/LICENSE

@@ -1,24 +1,22 @@
 Copyright (c) 2012, CubeSystems <info@cubesystems.lv>
-All rights reserved.
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the CubeSystems nor the names of its contributors may
-      be used to endorse or promote products derived from this software without
-      specific prior written permission.
+MIT License
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL CubeSystems BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/app/builders/releaf/i18n_database/translations/builders_common.rb

@@ -7,7 +7,7 @@ module Releaf::I18nDatabase::Translations
 
     def export_button
       url = action_url(:export, format: :xlsx)
-      button(t("export"), "download", class: "secondary", href: url)
+      button(t("Export"), "download", class: "secondary", href: url)
     end
   end
 end

data/app/builders/releaf/i18n_database/translations/index_builder.rb

@@ -24,7 +24,7 @@ module Releaf::I18nDatabase::Translations
     end
 
     def import_button
-      button(t("import"), "upload", name: "import", class: "secondary")
+      button(t("Import"), "upload", name: "import", class: "secondary")
     end
 
     def import_form

data/app/controllers/releaf/i18n_database/translations_controller.rb

@@ -1,171 +1,165 @@
-module Releaf::I18nDatabase
-  class TranslationsController < ::Releaf::BaseController
-    def self.resource_class
-      Releaf::I18nDatabase::Translation
-    end
+class Releaf::I18nDatabase::TranslationsController < ::Releaf::ActionController
+  def self.resource_class
+    Releaf::I18nDatabase::I18nEntry
+  end
 
-    def edit
-      @collection = resources
-      search(params[:search])
-    end
+  def edit
+    @collection = resources
+    search(params[:search])
+  end
 
-    def export
-      @collection = resources
-      search(params[:search])
+  def export
+    @collection = resources
+    search(params[:search])
 
-      respond_to do |format|
-        format.xlsx do
-          response.headers['Content-Disposition'] = "attachment; filename=\"#{export_file_name}\""
-        end
+    respond_to do |format|
+      format.xlsx do
+        response.headers['Content-Disposition'] = "attachment; filename=\"#{export_file_name}\""
       end
     end
+  end
 
-    def build_breadcrumbs
-      super
+  def build_breadcrumbs
+    super
 
-      if %w[edit update].include?(params[:action]) && !params.has_key?(:import)
-        @breadcrumbs << { name: I18n.t("edit translations", scope: controller_scope_name), url: url_for(action: :edit, search: params[:search]) }
-      end
+    if %w[edit update].include?(params[:action]) && !params.has_key?(:import)
+      @breadcrumbs << { name: I18n.t("Edit translations", scope: controller_scope_name), url: url_for(action: :edit, search: params[:search]) }
     end
+  end
+
+  def update
+    @collection = []
+    @translations_to_save = []
+
+    valid = build_updatables(params[:translations])
+    import_view if params.has_key?(:import)
 
-    def update
-      @collection = []
-      @translations_to_save = []
-
-      valid = build_updatables(params[:translations])
-      import_view if params.has_key?(:import)
-
-      respond_to do |format|
-        format.html do
-          if valid
-            process_updatables
-            update_response_success
-          else
-            render_notification false, now: true
-            render action: :edit
-          end
+    respond_to do |format|
+      format.html do
+        if valid
+          process_updatables
+          update_response_success
+        else
+          render_notification false, now: true
+          render action: :edit
         end
       end
     end
+  end
 
-    def resources
-      Releaf::I18nDatabase::TranslationsUtilities.include_localizations(super).order(:key)
-    end
+  def resources
+    Releaf::I18nDatabase::TranslationsUtilities.include_localizations(super).order(:key)
+  end
 
-    # overwrite search here
-    def search(lookup_string)
-      @collection = Releaf::I18nDatabase::TranslationsUtilities.search(@collection, lookup_string, params[:only_blank].present?)
-    end
+  # overwrite search here
+  def search(lookup_string)
+    @collection = Releaf::I18nDatabase::TranslationsUtilities.search(@collection, lookup_string, params[:only_blank].present?)
+  end
 
-    def import
-      if File.exists?(import_file_path) && !import_file_extension.blank?
-        begin
-          @collection = Releaf::I18nDatabase::TranslationsImporter.new(import_file_path, import_file_extension).parsed_output
-          import_view
-          render :edit
-        rescue Releaf::I18nDatabase::TranslationsImporter::UnsupportedFileFormatError
-          flash["error"] = { "id" => "resource_status", "message" => I18n.t("Unsupported file format", scope: notice_scope_name) }
-          redirect_to action: :index
-        end
-      else
+  def import
+    if File.exist?(import_file_path)
+      begin
+        @collection = Releaf::I18nDatabase::ParseSpreadsheetTranslations.call(file_path: import_file_path, extension: import_file_extension)
+        import_view
+        render :edit
+      rescue Releaf::I18nDatabase::ParseSpreadsheetTranslations::UnsupportedFileFormatError
+        flash["error"] = { "id" => "resource_status", "message" => I18n.t("Unsupported file format", scope: notice_scope_name) }
         redirect_to action: :index
       end
+    else
+      redirect_to action: :index
     end
+  end
 
-    def import_view
-      @import = true
-      @breadcrumbs << { name: I18n.t("import", scope: controller_scope_name) }
-    end
-
-    def setup
-      super
-      @features = {
-        index: true
-      }
-    end
+  def import_view
+    @import = true
+    @breadcrumbs << { name: I18n.t("import", scope: controller_scope_name) }
+  end
 
-    def action_views
-      super.merge(import: :edit)
-    end
+  def features
+    [:index, :search]
+  end
 
-    def action_features
-      {index: :index}.with_indifferent_access
-    end
+  def action_views
+    super.merge(import: :edit)
+  end
 
-    private
+  def action_features
+    {index: :index}.with_indifferent_access
+  end
 
-    def process_updatables
-      resource_class.where(id: @translation_ids_to_destroy).destroy_all unless @translation_ids_to_destroy.empty?
-      @translations_to_save.map(&:save!)
-      Releaf::I18nDatabase::Backend.translations_updated_at = Time.now
-    end
+  private
 
-    def build_updatables translations_params
-      valid = true
-      @translation_ids_to_destroy = params.fetch(:existing_translations, "").split(",")
+  def process_updatables
+    resource_class.where(id: @translation_ids_to_destroy).destroy_all unless @translation_ids_to_destroy.empty?
+    @translations_to_save.map(&:save!)
+    Releaf::I18nDatabase::Backend.translations_updated_at = Time.now
+  end
 
-      translations_params ||= []
-      translations_params.each do |values|
-        translation = load_translation(values["key"], values["localizations"])
+  def build_updatables translations_params
+    valid = true
+    @translation_ids_to_destroy = params.fetch(:existing_translations, "").split(",")
 
-        if translation.valid?
-          @translations_to_save << translation
-          @translation_ids_to_destroy.delete(translation.id.to_s)
-        else
-          valid = false
-        end
+    translations_params ||= []
+    translations_params.each do |values|
+      translation = load_translation(values["key"], values["localizations"])
 
-        @collection << translation
+      if translation.valid?
+        @translations_to_save << translation
+        @translation_ids_to_destroy.delete(translation.id.to_s)
+      else
+        valid = false
       end
 
-      valid
+      @collection << translation
     end
 
-    def load_translation(key, localizations)
-      translation = Releaf::I18nDatabase::Translation.where(key: key).first_or_initialize
-      translation.key = key
+    valid
+  end
 
-      localizations.each_pair do |locale, localization|
-        load_translation_data(translation, locale, localization)
-      end
+  def load_translation(key, localizations)
+    translation = Releaf::I18nDatabase::I18nEntry.where(key: key).first_or_initialize
+    translation.key = key
 
-      translation
+    localizations.each_pair do |locale, localization|
+      load_translation_data(translation, locale, localization)
     end
 
-    def load_translation_data(translation, locale, localization)
-      translation_data = translation.translation_data.find{ |x| x.lang == locale }
-      # replace existing locale value only if new one is not blank
-      if translation_data
-        translation_data.localization = localization
-        # always assign value for new locale
-      elsif translation_data.nil?
-        translation_data = translation.translation_data.build(lang: locale, localization: localization)
-      end
+    translation
+  end
 
-      translation_data
-    end
+  def load_translation_data(translation, locale, localization)
+    translation_data = translation.find_or_initialize_translation(locale)
 
-    def update_response_success
-      if @import
-        msg = 'successfuly imported %{count} translations'
-        flash["success"] = { "id" => "resource_status", "message" => I18n.t(msg, default: msg, count: @translations_to_save.size , scope: notice_scope_name) }
-        redirect_to action: :index
-      else
-        render_notification true
-        redirect_to({action: :edit}.merge(request.query_parameters))
-      end
+    if localization.present?
+      translation_data.text = localization
+    else
+      translation_data.mark_for_destruction
     end
 
-    def export_file_name
-      "#{Rails.application.class.parent_name.underscore}_translations_#{Time.now.strftime('%Y_%m_%d_%H_%M_%S')}.xlsx"
-    end
+    translation_data
+  end
 
-    def import_file_path
-      params[:import_file].try(:tempfile).try(:path).to_s
+  def update_response_success
+    if @import
+      msg = 'successfuly imported %{count} translations'
+      flash["success"] = { "id" => "resource_status", "message" => I18n.t(msg, default: msg, count: @translations_to_save.size , scope: notice_scope_name) }
+      redirect_to action: :index
+    else
+      render_notification true
+      redirect_to({action: :edit}.merge(request.query_parameters))
     end
+  end
 
-    def import_file_extension
-      File.extname(params[:import_file].original_filename).gsub(".", "")
-    end
+  def export_file_name
+    "#{Rails.application.class.parent_name.underscore}_translations_#{Time.now.strftime('%Y_%m_%d_%H_%M_%S')}.xlsx"
+  end
+
+  def import_file_path
+    params[:import_file].try(:tempfile).try(:path).to_s
+  end
+
+  def import_file_extension
+    File.extname(params[:import_file].original_filename).tr(".", "")
   end
 end

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

@@ -0,0 +1,62 @@
+module Releaf::I18nDatabase
+  class ParseSpreadsheetTranslations
+    class UnsupportedFileFormatError < StandardError; end
+    include Releaf::Service
+    attribute :file_path, String
+    attribute :extension, String
+
+    def call
+      translations
+    end
+
+    def rows
+      @rows ||= spreadsheet.to_a
+    end
+
+    def data_rows
+      rows[1..-1].reject{|row| row.first.blank? }
+    end
+
+    def locales
+      @locales ||= rows.first.reject(&:blank?)
+    end
+
+    def spreadsheet
+      begin
+        Roo::Spreadsheet.open(file_path, extension: extension, file_warning: :ignore)
+      rescue StandardError => e
+        if file_format_error?(e.class.name, e.message)
+          raise UnsupportedFileFormatError
+        else
+          raise
+        end
+      end
+    end
+
+    def file_format_error?(error_class_name, error_message)
+      return true if ['Zip::ZipError','Ole::Storage::FormatError' ].include?(error_class_name)
+      error_class_name == 'ArgumentError' && error_message.match("Don't know how to open file").present?
+    end
+
+    def translations
+      data_rows.map do |row|
+        translation_instance(row.first, row[1..-1].map(&:to_s))
+      end
+    end
+
+    def translation_instance(key, localizations)
+      translation = Releaf::I18nDatabase::I18nEntry.where(key: key).first_or_initialize
+      maintain_translation_locales(translation, localizations)
+
+      translation
+    end
+
+    def maintain_translation_locales(translation, localizations)
+      locales.each_with_index do|locale, i|
+        locale_translation = translation.i18n_entry_translation.find{|item| item.locale == locale }
+        locale_translation ||= translation.i18n_entry_translation.build(locale: locale, text: "")
+        locale_translation.text = localizations[i] if localizations[i].present?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+class Releaf::I18nDatabase::TranslationsStore
+  include Releaf::InstanceCache
+  attr_accessor :updated_at, :missing_keys
+
+  def initialize
+    self.updated_at = Releaf::I18nDatabase::Backend.translations_updated_at
+    self.missing_keys = {}
+  end
+
+  def expired?
+    updated_at != Releaf::I18nDatabase::Backend.translations_updated_at
+  end
+
+  def exist?(key)
+    stored_keys.key? key
+  end
+
+  def lookup(locale, key, options)
+    translation_keys = key.split('.')
+
+    (1..translation_keys.length).each do|i|
+      result = dig_valid_translation(locale, translation_keys, i == 1, options)
+      return result if returnable_result?(result, options)
+      # remove second last value (going up to scope chain)
+      translation_keys.delete_at(translation_keys.length - 2)
+    end
+
+    nil
+  end
+
+  def dig_translation(locale, translation_keys)
+    translation_keys.inject(stored_translations[locale.to_sym]) do |h, key|
+      h[key.to_sym] if h.is_a?(Hash)
+    end
+  end
+
+  def dig_valid_translation(locale, translation_keys, first_lookup, options)
+    result = dig_translation(locale, translation_keys)
+    if invalid_result?(locale, result, first_lookup, options)
+      nil
+    else
+      result
+    end
+  end
+
+  def invalid_result?(locale, result, first_lookup, options)
+    invalid_nonpluralized_result?(result, first_lookup, options) || invalid_pluralized_result?(locale, result, options)
+  end
+
+  def invalid_nonpluralized_result?(result, first_lookup, options)
+    result.is_a?(Hash) && !first_lookup && !options.has_key?(:count)
+  end
+
+  def invalid_pluralized_result?(locale, result, options)
+    result.is_a?(Hash) && options.has_key?(:count) && !valid_pluralized_result?(locale, options[:count], result)
+  end
+
+  def valid_pluralized_result?(locale, count, result)
+    return false unless TwitterCldr.supported_locale?(locale)
+    result.key?(TwitterCldr::Formatters::Plurals::Rules.rule_for(count, locale))
+  end
+
+  def returnable_result?(result, options)
+    result.present? || options.fetch(:inherit_scopes, true) == false
+  end
+
+  def localization_data
+    Releaf::I18nDatabase::I18nEntryTranslation
+      .joins(:i18n_entry)
+      .where.not(text: '')
+      .pluck("CONCAT(locale, '.', releaf_i18n_entries.key) AS translation_key", "text")
+      .to_h
+  end
+
+  def stored_keys
+    Releaf::I18nDatabase::I18nEntry.pluck(:key).inject({}) do|h, key|
+      h.update(key => true)
+    end
+  end
+
+  def stored_translations
+    stored_keys.map do |key, _|
+      key_hash(key)
+    end.inject(&:deep_merge) || {}
+  end
+
+  def key_hash(key)
+    config.all_locales.inject({}) do |h, locale|
+      localized_key = "#{locale}.#{key}"
+      locale_hash = key_locale_hash(localized_key, localization_data[localized_key])
+      h.merge(locale_hash)
+    end
+  end
+
+  def config
+    Releaf.application.config
+  end
+
+  def missing?(locale, key)
+    missing_keys.key? "#{locale}.#{key}"
+  end
+
+  def missing(locale, key, options)
+    # mark translation as missing
+    missing_keys["#{locale}.#{key}"] = true
+    auto_create(key, options) if auto_create?(key, options)
+  end
+
+  def auto_create?(key, options)
+    return false unless config.i18n_database.translation_auto_creation
+    return false if options[:auto_create] == false
+    return false unless auto_creation_inclusion?(key)
+    return false if auto_creation_exception?(key)
+    return false if stored_keys.key?(key)
+    true
+  end
+
+  def auto_creation_inclusion?(key)
+    config.i18n_database.translation_auto_creation_patterns.find{|pattern| key.match(pattern) }.present?
+  end
+
+  def auto_creation_exception?(key)
+    config.i18n_database.translation_auto_creation_exclusion_patterns.find{|pattern| key.match(pattern) }.present?
+  end
+
+  def auto_create(key, options)
+    if pluralizable_translation?(options)
+      Releaf::I18nDatabase::Backend.locales_pluralizations.each do|pluralization|
+        Releaf::I18nDatabase::I18nEntry.create(key: "#{key}.#{pluralization}")
+      end
+    else
+      Releaf::I18nDatabase::I18nEntry.create(key: key)
+    end
+  end
+
+  def pluralizable_translation?(options)
+    options.has_key?(:count) && options[:create_plurals] == true
+  end
+
+  cache_instance_methods :stored_translations, :stored_keys, :localization_data
+
+  private
+
+  def key_locale_hash(localized_key, localization)
+    localized_key.split(".").reverse.inject(localization) do |value, key|
+      {key.to_sym => value}
+    end
+  end
+end