i18n_admin 0.3.1

data/db/migrate/20150828074645_create_i18n_admin_whitelisted_resources.rb

@@ -0,0 +1,12 @@
+class CreateI18nAdminWhitelistedResources < ActiveRecord::Migration
+  def change
+    create_table :i18n_admin_whitelisted_resources do |t|
+      t.references :resource, polymorphic: true
+
+      t.timestamps null: false
+    end
+
+    add_index :i18n_admin_whitelisted_resources, [:resource_id, :resource_type],
+              name: 'whitelisted_resources_foreign_key_index'
+  end
+end

data/db/migrate/20160404161658_create_i18n_admin_resource_files.rb

@@ -0,0 +1,11 @@
+class CreateI18nAdminResourceFiles < ActiveRecord::Migration
+  def change
+    create_table :i18n_admin_resource_files do |t|
+      t.string :type
+      t.string :job_id
+      t.attachment :file
+
+      t.timestamps null: false
+    end
+  end
+end

data/lib/ext/paperclip.rb

@@ -0,0 +1,5 @@
+# Fixes excel uploading
+#
+if Paperclip.options[:content_type_mappings]
+  Paperclip.options[:content_type_mappings][:xls] = "CDF V2 Document, No summary info"
+end

data/lib/generators/i18n_admin/install/install_generator.rb

@@ -0,0 +1,31 @@
+module I18nAdmin
+  class InstallGenerator < Rails::Generators::Base
+    # Copied files come from templates folder
+    source_root File.expand_path('../templates', __FILE__)
+
+    # Generator desc
+    desc "I18nAdmin install generator"
+
+    def mount_engine
+      mount_path = ask(
+        "Where would you like to mount I18nAdmin engine ? [/i18n-admin]"
+      ).presence || '/i18n-admin'
+      mount_path = mount_path.match(/^\//) ? mount_path : "/#{ mount_path }"
+
+      gsub_file "config/routes.rb", /mount I18nAdmin.*\n/, ''
+
+      route "mount I18nAdmin::Engine => '#{ mount_path }', as: 'i18n_admin'"
+    end
+
+    def copy_initializer
+      copy_file "initializer.rb", "config/initializers/i18n_admin.rb"
+    end
+
+    def install_migrations
+      say "Installing migrations ..."
+      rake 'i18n_admin:install:migrations'
+      say "Migrations installed, don't forget to run `rake db:migrate` to " \
+          "make the translation system work"
+    end
+  end
+end

data/lib/generators/i18n_admin/install/templates/initializer.rb

@@ -0,0 +1,28 @@
+I18nAdmin.config do |config|
+  # User authentication method for the admin panel
+  #
+  # config.authentication_method = :authenticate_user!
+
+  # Method to retrieve the current user
+  #
+  # config.current_user_method = :current_user
+
+  # Define a pattern that will exclude keys from the shown administrable
+  # translations
+  #
+  # For example, to exclude all activerecord translations :
+  #   config.excluded_keys_pattern = /^activerecord\./
+  #
+  # config.excluded_keys_pattern = nil
+
+  # When exporting translations, all translated models are exported.
+  # If you want to be able to whitelist exportable models, set the
+  # following option to true
+  #
+  # config.whitelist_models = false
+
+  # If you want imports and exports to be processed asynchronously through
+  # `ActiveJob`, set the following to true.
+  #
+  # config.async_io = false
+end

data/lib/i18n_admin.rb

@@ -0,0 +1,51 @@
+require 'kaminari'
+require 'request_store'
+require 'spreadsheet'
+require 'active_model'
+require 'turbolinks'
+require 'nprogress-rails'
+require 'sucker_punch'
+require 'sidekiq'
+require 'sidekiq/job_monitor'
+require 'paperclip'
+require 'font-awesome-rails'
+
+require 'ext/paperclip'
+
+require "i18n_admin/request_store"
+require "i18n_admin/hstore_backend"
+require "i18n_admin/translations"
+require "i18n_admin/translation_collection"
+require "i18n_admin/translation"
+
+require "i18n_admin/errors"
+require "i18n_admin/export"
+require "i18n_admin/import"
+
+require "i18n_admin/engine"
+
+module I18nAdmin
+  mattr_accessor :root_controller_parent
+  @@root_controller_parent = '::ActionController::Base'
+
+  mattr_accessor :authentication_method
+  @@authentication_method = :authenticate_user!
+
+  mattr_accessor :current_user_method
+  @@current_user_method = :current_user
+
+  mattr_accessor :excluded_keys_pattern
+  @@excluded_keys_pattern = nil
+
+  mattr_accessor :whitelist_models
+  @@whitelist_models = false
+
+  mattr_accessor :async_io
+  @@async_io = false
+
+  def self.config(&block)
+    block_given? ? yield(self) : self
+  end
+end
+
+Mime::Type.register "application/xls", :xls

data/lib/i18n_admin/engine.rb

@@ -0,0 +1,28 @@
+module I18nAdmin
+  class Engine < ::Rails::Engine
+    isolate_namespace I18nAdmin
+
+    initializer 'i18n_admin.configure_i18n_backend' do
+      translations_installed = begin
+        I18nAdmin::TranslationsSet.select('1').inspect
+        true
+      rescue
+        false
+      end
+
+      table_existence = ActiveRecord::Base.connection.table_exists? 'i18n_admin_translations_sets'
+      if translations_installed && table_existence
+        I18n.backend = I18n::Backend::Chain.new(
+          I18nAdmin::HstoreBackend.new,
+          I18n.backend
+        )
+      end
+    end
+
+    initializer 'i18n_admin.add_assets_to_precompilation', group: :all do |app|
+      app.config.assets.precompile += %w(
+        'i18n_admin/spinner.gif'
+      )
+    end
+  end
+end

data/lib/i18n_admin/errors.rb

@@ -0,0 +1,10 @@
+module I18nAdmin
+  module Errors
+  end
+end
+
+require 'i18n_admin/errors/base'
+require 'i18n_admin/errors/collection'
+
+require 'i18n_admin/errors/resource_not_found'
+require 'i18n_admin/errors/resource_invalid'

data/lib/i18n_admin/errors/base.rb

@@ -0,0 +1,23 @@
+module I18nAdmin
+  module Errors
+    class Base
+      def initialize(attributes = {})
+        assign_attributes(attributes)
+      end
+
+      def assign_attributes(attributes = {})
+        attributes.each do |key, value|
+          public_send(:"#{ key }=", value)
+        end
+      end
+
+      def messages
+        @messages ||= []
+      end
+
+      def type
+        self.class.name.demodulize.underscore.to_sym
+      end
+    end
+  end
+end

data/lib/i18n_admin/errors/collection.rb

@@ -0,0 +1,24 @@
+module I18nAdmin
+  module Errors
+    class Collection < Hash
+      def add(error_or_type, options = {})
+        error = error_instance_from(error_or_type, options)
+
+        self[error.type] ||= []
+        self[error.type] << error
+      end
+
+      private
+
+      def error_instance_from(error_or_type, options = {})
+        if Symbol === error_or_type
+          camelized = error_or_type.to_s.camelize
+          type = ['I18nAdmin', 'Errors', camelized].join('::').constantize
+          type.new(options)
+        else
+          error_or_type
+        end
+      end
+    end
+  end
+end

data/lib/i18n_admin/errors/resource_invalid.rb

@@ -0,0 +1,7 @@
+module I18nAdmin
+  module Errors
+    class ResourceInvalid < Errors::Base
+      attr_accessor :key, :resource
+    end
+  end
+end

data/lib/i18n_admin/errors/resource_not_found.rb

@@ -0,0 +1,7 @@
+module I18nAdmin
+  module Errors
+    class ResourceNotFound < Errors::Base
+      attr_accessor :key, :model_name, :id
+    end
+  end
+end

data/lib/i18n_admin/export.rb

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

data/lib/i18n_admin/export/base.rb

@@ -0,0 +1,129 @@
+module I18nAdmin
+  module Export
+    class Base
+      include Sidekiq::Worker
+
+      attr_reader :locale
+
+      def self.register(type, export)
+        Export.types[type] = export
+      end
+
+      private
+
+      def translations
+        @translations ||=
+          translations_for_locale(locale).merge(
+            models_translations_for(locale)
+          )
+      end
+
+      def original_translations
+        @original_translations ||=
+          I18nAdmin::Translations.for_locale(I18n.default_locale).merge(
+            models_translations_for(I18n.default_locale)
+          )
+      end
+
+      def translations_for_locale(locale)
+        I18nAdmin::Translations.for_locale(locale).select do |key, value|
+          if (pattern = I18nAdmin.excluded_keys_pattern)
+            !key.match(pattern)
+          else
+            true
+          end
+        end
+      end
+
+      def models_translations_for(locale)
+        model_translations = {}
+
+        I18n.with_locale(locale) do
+          translated_models.each do |model, attributes|
+            whitelisted_resources_for(model).each do |resource|
+              attributes.each do |attribute|
+                key = model_translation_key_for(resource, attribute)
+                model_translations[key] = resource.send(attribute).to_s
+              end
+            end
+          end
+        end
+
+        model_translations
+      end
+
+      def model_translation_key_for(resource, attribute)
+        ['models', resource.class.name, resource.id, attribute].join('-')
+      end
+
+      def translated_models
+        @translated_models ||= begin
+          if defined?(Globalize) || defined?(Para::I18n)
+            fetch_translated_models
+          else
+            []
+          end
+        end
+      end
+
+      def fetch_translated_models
+        model_names.each_with_object({}) do |model_name, models|
+          begin
+            model = model_name.constantize
+
+            if model.respond_to?(:translates?) && model.translates?
+              models[model] = model.translated_attribute_names
+            end
+          rescue LoadError
+            next
+          end
+        end
+      end
+
+      # Borrowed from Rails Admin
+      def model_names
+        @model_names ||=
+          ([Rails.application] + Rails::Engine.subclasses.map(&:instance)).flat_map do |app|
+            (app.paths['app/models'].to_a + app.config.autoload_paths).map do |load_path|
+              Dir.glob(app.root.join(load_path)).map do |load_dir|
+                Dir.glob(load_dir + '/**/*.rb').map do |filename|
+                  next unless filename.match(/\/models\//)
+                  # app/models/module/class.rb => module/class.rb => module/class => Module::Class
+                  lchomp(filename, "#{app.root.join(load_dir)}/").chomp('.rb').camelize
+                end
+              end
+            end
+          end.flatten.compact.uniq
+      end
+
+      def lchomp(base, arg)
+        base.to_s.reverse.chomp(arg.to_s.reverse).reverse
+      end
+
+      # If the `whitelist_models` option is set to true in the initializer,
+      # only fetch the explicitly whitelisted resources for each model
+      #
+      def whitelisted_resources_for(model)
+        resource_id_field = [model.table_name, model.primary_key].join('.')
+
+        whitelisted_resources =
+          if I18nAdmin.whitelist_models
+            model.joins(
+              'INNER JOIN i18n_admin_whitelisted_resources AS whitelist ' \
+              "ON whitelist.resource_id = #{ resource_id_field }"
+            ).where(whitelist: { resource_type: model.name })
+          else
+            model.all
+          end
+
+        whitelisted_resources = whitelisted_resources.order("#{ resource_id_field } ASC")
+
+        if defined?(Globalize)
+          whitelisted_resources.includes(:translations)
+        else
+          whitelisted_resources
+        end
+      end
+    end
+  end
+end

data/lib/i18n_admin/export/xls.rb

@@ -0,0 +1,110 @@
+module I18nAdmin
+  module Export
+    class XLS < Export::Base
+      register :xls, self
+
+      PAGE_LENGTH = 32_000.0
+
+      attr_reader :spreadsheet, :sheet
+      attr_accessor :export_file
+
+      def perform(locale)
+        @locale = locale
+        @spreadsheet = Spreadsheet::Workbook.new
+        @sheet = spreadsheet.create_worksheet
+
+        add_headers!
+
+        run
+        save
+      end
+
+      def run
+        default_format = Spreadsheet::Format.new(text_wrap: true)
+
+        index = 0
+
+        translations.each do |key, value|
+          value = value.to_s
+          original_translation = original_translations[key].to_s
+          max_length = [value.length, original_translation.length].max
+          pages = (max_length / PAGE_LENGTH).ceil
+
+          pages.times do |page|
+            index += 1
+
+            translation_key = if pages > 1
+              "#{ key } (#{ page + 1 } / #{ pages })"
+            else
+              key
+            end
+
+            start_offset = page * PAGE_LENGTH
+
+            row = sheet.row(index)
+            row.default_format = default_format
+            row.push(translation_key)
+            row.push(original_translation[start_offset, PAGE_LENGTH])
+            row.push(value[start_offset, PAGE_LENGTH])
+          end
+        end
+      end
+
+      def save
+        spreadsheet.write(file_path)
+
+        source = File.open(file_path, 'rb')
+        self.export_file = ExportFile.create!(job_id: job_id, file: source)
+      ensure
+        if defined?(source) && source
+          source.close
+          File.unlink(source.path)
+        end
+      end
+
+      def file_path
+        @file_path ||= [
+          '',
+          'tmp',
+          I18n.t('i18n_admin.exports.file.name', time: Time.now.strftime('%Y_%m_%d-%H_%M'), lang: locale, ext: 'xls')
+        ].join('/')
+      end
+
+      def monitoring_data(_, state)
+        { url: export_file.file.url } if state == 'complete'
+      end
+
+      def export_file
+        @export_file ||= ExportFile.find_by_job_id(job_id)
+      end
+
+      private
+
+      def add_headers!
+        sheet.row(0).replace(
+          [
+            I18n.t('i18n_admin.exports.file.columns.key'),
+            I18n.t('i18n_admin.exports.file.columns.original', lang: I18n.default_locale),
+            I18n.t('i18n_admin.exports.file.columns.translated', lang: locale)
+          ]
+        )
+
+        format = Spreadsheet::Format.new weight: :bold
+
+        sheet.row(0).default_format = format
+
+        sheet.column(0).width = 30
+        sheet.column(1).width = 100
+        sheet.column(2).width = 100
+      end
+
+      def job_id
+        @job_id ||= jid || randomize_job_id
+      end
+
+      def randomize_job_id
+        ['sync', (Time.now.to_f * 1000).round, rand(1000)]
+      end
+    end
+  end
+end