i18n_admin 0.3.1

data/lib/i18n_admin/hstore_backend.rb

@@ -0,0 +1,68 @@
+require 'i18n/backend/key_value'
+
+module I18nAdmin
+  class HstoreBackend < I18n::Backend::KeyValue
+    def available_locales
+      @available_locales ||= I18nAdmin::TranslationsSet.pluck(:locale)
+    end
+
+    class Store
+      include I18nAdmin::RequestStore
+
+      def [](path)
+        locale, key = locale_and_key_from(path)
+        cached_translations_for(locale).translations[key]
+      end
+
+      def store_translations(locale, key, value)
+        translations_set = translations_set_for(locale)
+        translations_set.translations[key] = value
+        translations_set.translations_will_change!
+        translations_set.save
+        value
+      end
+
+      def translations_for(locale)
+        translations_set_for(locale).translations
+      end
+
+      private
+
+      def locale_and_key_from(path)
+        path.split('.', 2)
+      end
+
+      def translations_set_for(locale)
+        model.where(locale: locale).first_or_initialize do |set|
+          set.translations ||= {}
+        end
+      end
+
+      def cached_translations_for(locale)
+        store_key = store_key_for(locale, :set)
+        request_store.store[store_key] ||= translations_set_for(locale)
+      end
+
+      def model
+        @model ||= I18nAdmin::TranslationsSet
+      end
+    end
+
+    def initialize
+      @store = HstoreBackend::Store.new
+    end
+
+    def store_translations(locale, data, options = {})
+      data.each do |key, value|
+        store.store_translations(locale, key, value)
+      end
+    end
+
+    protected
+
+    def lookup(locale, key, scope = [], options = {})
+      key = normalize_flat_keys(locale, key, scope, options[:separator])
+      store["#{locale}.#{key}"]
+    end
+  end
+end

data/lib/i18n_admin/import.rb

@@ -0,0 +1,16 @@
+module I18nAdmin
+  module Import
+    def self.types
+      @types ||= {}
+    end
+
+    def self.for(format)
+      types[format]
+    end
+  end
+end
+
+require 'i18n_admin/import/base'
+require 'i18n_admin/import/xls'
+
+require 'i18n_admin/import/job'

data/lib/i18n_admin/import/base.rb

@@ -0,0 +1,64 @@
+module I18nAdmin
+  module Import
+    class Base
+      attr_reader :locale
+
+      def self.register(type, import)
+        Import.types[type] = import
+      end
+
+      def errors
+        @errors ||= I18nAdmin::Errors::Collection.new
+      end
+
+      private
+
+      def save_updated_models
+        # Save all updated model translations
+        ActiveRecord::Base.transaction do
+          updated_models.each do |key, resource|
+            unless resource.save
+              errors.add(:resource_invalid, key: key, resource: resource)
+            end
+          end
+        end
+      end
+
+      def update_translation(key, value)
+        case key
+        when /^models\-/ then update_model_translation(key, value)
+        else update_static_translation(key, value)
+        end
+      end
+
+      def update_model_translation(key, value)
+        _, model_name, id, field = key.split('-')
+        update_cache_key = [model_name, id].join('-')
+
+        # Find resource from update cache, or in database
+        unless (resource = updated_models[update_cache_key])
+          model = model_name.constantize
+          resource = model.where(id: id).first
+        end
+
+        # Only update found resources
+        if resource
+          resource.send(:"#{ field }=", value)
+          updated_models[update_cache_key] ||= resource
+        else
+          errors.add(:resource_not_found, {
+            key: update_cache_key, model_name: model_name, id: id
+          })
+        end
+      end
+
+      def update_static_translation(key, value)
+        I18n.backend.store_translations(locale, key => value)
+      end
+
+      def updated_models
+        @updated_models ||= {}
+      end
+    end
+  end
+end

data/lib/i18n_admin/import/job.rb

@@ -0,0 +1,17 @@
+module I18nAdmin
+  module Import
+    class Job
+      include SuckerPunch::Job
+
+      def perform(locale, file_path, job_id)
+        ActiveRecord::Base.connection_pool.with_connection do
+          import = Import::XLS.new(locale, file_path)
+          job = I18nAdmin::ImportJob.find(job_id)
+
+          state = import.run ? 'success' : 'error'
+          job.update(state: state)
+        end
+      end
+    end
+  end
+end

data/lib/i18n_admin/import/xls.rb

@@ -0,0 +1,58 @@
+module I18nAdmin
+  module Import
+    class XLS < Import::Base
+      # Used to split cells with large content
+      PAGINATION_PATTERN = /\(\d+ \/ (\d+)\)$/
+
+      register :xls, self
+
+      attr_reader :file, :spreadsheet, :sheet
+
+      def self.import(locale, file)
+        import = new(locale, file)
+        import.run
+      ensure
+        file.close
+      end
+
+      def initialize(locale, file)
+        @locale = locale
+        @spreadsheet = Spreadsheet.open(file.path)
+        @sheet = spreadsheet.worksheet(0)
+      end
+
+      def run
+        I18n.with_locale(locale) do
+          index = 0
+
+          while (index += 1) < sheet.row_count
+            key, value, index = extract_translation_at(index)
+            update_translation(key, value)
+          end
+
+          save_updated_models
+        end
+
+        errors.empty?
+      end
+
+      private
+
+      def extract_translation_at(index)
+        key, _, value = sheet.row(index)
+
+        if (pagination = key.match(PAGINATION_PATTERN))
+          pages = pagination[1].to_i
+          key = key.gsub(PAGINATION_PATTERN, '').strip
+
+          (pages - 1).times do |page|
+            index += 1
+            value += sheet.row(index).pop.to_s
+          end
+        end
+
+        [key, value, index]
+      end
+    end
+  end
+end

data/lib/i18n_admin/request_store.rb

@@ -0,0 +1,11 @@
+module I18nAdmin
+  module RequestStore
+    def request_store
+      ::RequestStore
+    end
+
+    def store_key_for(*args)
+      [:i18n_admin, *args].join(':')
+    end
+  end
+end

data/lib/i18n_admin/translation.rb

@@ -0,0 +1,27 @@
+require 'base64'
+
+module I18nAdmin
+  class Translation
+    include ActiveModel::Model
+
+    attr_accessor :key, :original, :value, :locale
+
+    def persisted?
+      true
+    end
+
+    def to_param
+      Base64.strict_encode64(key)
+    end
+
+    def matches?(search)
+      [:key, :original, :value].any? do |key|
+        send(key).to_s.match(search)
+      end
+    end
+
+    def self.key_from(encoded_key)
+      Base64.decode64(encoded_key)
+    end
+  end
+end

data/lib/i18n_admin/translation_collection.rb

@@ -0,0 +1,34 @@
+module I18nAdmin
+  class TranslationCollection
+    include Enumerable
+
+    attr_writer :translations
+
+    delegate :<<, :each, :[], :[]=, :length, to: :translations
+
+    def translations
+      @translations ||= []
+    end
+
+    def page(page_index)
+      Kaminari.paginate_array(self).page(page_index)
+    end
+
+    def search(query)
+      regex = /#{ query.split(' ').join('|') }/i
+
+      # Duplicate and filter translations
+      updated = dup
+      updated.translations.select! { |translation| translation.matches?(regex) }
+      updated
+    end
+
+    def find(encoded_key)
+      key = I18nAdmin::Translation.key_from(encoded_key)
+
+      translations.find do |translation|
+        translation.key == key
+      end
+    end
+  end
+end

data/lib/i18n_admin/translations.rb

@@ -0,0 +1,96 @@
+module I18nAdmin
+  class Translations
+    include I18nAdmin::RequestStore
+
+    def self.translations_for(locale)
+      translations = TranslationCollection.new
+
+      for_locale(locale).each do |key, value|
+        translations << Translation.new(
+          key: key,
+          original: for_locale(I18n.default_locale)[key],
+          value: value,
+          locale: locale
+        )
+      end
+
+      translations
+    end
+
+    def self.for_locale(locale)
+      new.for_locale(locale.to_sym)
+    end
+
+    # Save a translation object
+    def self.update(translation)
+      I18n.backend.store_translations(
+        translation.locale,
+        translation.key => translation.value
+      )
+
+      if translation.locale == I18n.default_locale
+        translation.original = translation.value
+      end
+    end
+
+    def for_locale(locale = I18n.locale)
+      translations = with_empty_keys_for(locale, all_translations_for(locale))
+
+      translations.keys.sort.each_with_object({}) do |key, hash|
+        hash[key] = translations[key]
+      end
+    end
+
+    def all_translations_for(locale)
+      request_store.store[store_key_for(locale, :hash)] ||= backends.map do |backend|
+        translations_for(locale, backend)
+      end.reduce(&:reverse_merge)
+    end
+
+    def backends
+      @backends ||= I18n.backend.backends
+    end
+
+    def translations_for(locale, backend)
+      translations = if backend.protected_methods.include?(:translations)
+        parse_from_deep_hash(locale, backend.send(:translations))
+      elsif backend.respond_to?(:store)
+        backend.store.translations_for(locale)
+      end
+    end
+
+    def parse_from_deep_hash(locale, translations)
+      flatten_translation_hash(translations[locale] || {})
+    end
+
+    def flatten_translation_hash(hash, scope = nil, translations = {})
+      hash.each_with_object(translations) do |(key, value), buffer|
+        scoped_key = [scope, key.to_s].compact.join('.')
+
+        if value.is_a?(Hash)
+          flatten_translation_hash(value, scoped_key, buffer)
+        elsif elegible_key?(scoped_key)
+          buffer[scoped_key] = value
+        end
+      end
+    end
+
+    def elegible_key?(key)
+      if (pattern = I18nAdmin.excluded_keys_pattern)
+        !key.match(pattern)
+      else
+        true
+      end
+    end
+
+    def with_empty_keys_for(locale, hash)
+      return hash if I18n.default_locale == locale
+
+      all_translations_for(I18n.default_locale).keys.each do |key|
+        hash[key] = "" unless hash.key?(key)
+      end
+
+      hash
+    end
+  end
+end

data/lib/i18n_admin/version.rb

@@ -0,0 +1,3 @@
+module I18nAdmin
+  VERSION = "0.3.1"
+end

data/lib/tasks/i18n_admin_tasks.rake

@@ -0,0 +1,35 @@
+# desc "Explaining what the task does"
+# task :i18n_admin do
+#   # Task goes here
+# end
+
+namespace :i18n do
+  namespace :translations do
+    task export: :environment do
+      format = (ENV['format'] || 'xls').to_sym
+      locale = (ENV['locale'] || I18n.default_locale).to_sym
+
+      data = I18nAdmin::Export.for(format).export(locale)
+
+      file_name = ['translations', locale, format].join('.')
+      file_path = Rails.root.join('tmp', file_name)
+
+      File.open(file_path, 'wb') do |file|
+        file.write(data)
+      end
+
+      puts "Exported translations to : #{ file_path }"
+    end
+
+    task import: :environment do
+      format = (ENV['format'] || 'xls').to_sym
+      locale = (ENV['locale'] || I18n.default_locale).to_sym
+      file_path = ENV['file']
+      file = File.open(file_path, 'rb')
+
+      data = I18nAdmin::Import.for(format).import(locale, file)
+
+      puts "Imported translations from : #{ file_path }"
+    end
+  end
+end