rails_i18n_manager 1.0.0

data/app/helpers/rails_i18n_manager/custom_form_builder.rb

@@ -0,0 +1,223 @@
+module RailsI18nManager
+  class CustomFormBuilder < ActionView::Helpers::FormBuilder
+
+    ALLOWED_OPTIONS = [
+      :value,
+      :name,
+      :label,
+      :field_wrapper_html,
+      :label_wrapper_html,
+      :label_html,
+      :input_wrapper_html,
+      :input_html,
+      :required,
+      :required_text,
+      :help_text,
+      :errors,
+      :field_layout,
+      :view_mode,
+
+      ### SELECT OPTIONS
+      :collection,
+      :selected,
+      :disabled,
+      :prompt,
+      :include_blank,
+    ].freeze
+
+    def error_notification
+      @template.render "rails_i18n_manager/form_builder/error_notification", {f: self}
+    end
+
+    def view_field(label:, value:, **options)
+      field(nil, type: :view, **options.merge(label: label, value: value, view_mode: true))
+    end
+
+    def field(method, type:, **options)
+      type = type.to_sym
+
+      options = _transform_options(options, method)
+
+      if options[:view_mode]
+        return _view_field(method, type, options)
+      end
+
+      invalid_options = options.keys - ALLOWED_OPTIONS
+      if invalid_options.any?
+
+        raise "Invalid options provided: #{invalid_options.join(", ")}"
+      end
+
+      if [:select, :textarea].exclude?(type)
+        options[:input_html][:type] = type.to_s
+      end
+
+      case type
+      when :select
+        options[:collection] = _fetch_required_option(:collection, options)
+
+        options = _transform_select_options(options, method)
+      when :checkbox
+        options = _transform_checkbox_options(options, method)
+      else
+        if !options[:input_html].has_key?(:value)
+          options[:input_html][:value] = object.send(method)
+        end
+      end
+
+      @template.render("rails_i18n_manager/form_builder/basic_field", {
+        f: self,
+        method: method,
+        type: type,
+        options: options,
+      })
+    end
+
+    private
+
+    def _view_field(method, type, options)
+      options[:input_html][:class] ||= ""
+      options[:input_html][:class].concat(" form-control-plaintext").strip!
+      options[:input_html][:readonly] = true
+      options[:input_html][:type] = "text"
+      options[:input_html].delete(:name)
+
+      if !options[:input_html].has_key?(:value)
+        options[:input_html][:value] = _determine_display_value(method, type, options)
+      end
+
+      @template.render("rails_i18n_manager/form_builder/basic_field", {
+        f: self,
+        method: method,
+        type: :view,
+        options: options,
+      })
+    end
+
+    def _defaults
+      @_defaults ||= (@template.instance_variable_get(:@_custom_form_for_defaults) || {}).deep_symbolize_keys!
+    end
+
+    def _attr_presence_required?(attr)
+      if attr && object.respond_to?(attr)
+        (@object.try(:klass) || @object.class).validators_on(attr).any?{|x| x.kind.to_sym == :presence }
+      end
+    end
+
+    def _fetch_required_option(key, options)
+      if !options.has_key?(key)
+        raise ArgumentError.new("Missing required option :#{key}")
+      end
+      options[key]
+    end
+
+    def _determine_display_value(method, type, options)
+      case type
+      when :checkbox
+        options[:input_html]&.has_key?(:checked) ? options[:input_html][:checked] : @object.send(method)
+      when :select
+        if options.has_key?(:selected)
+          val = options[:selected]
+        else
+          if options[:input_html].has_key?(:value)
+            val = options[:input_html].delete(:value)
+          else
+            val = object.send(method)
+          end
+        end
+
+        selected_opt = options[:collection].detect { |opt|
+          val == (opt.is_a?(Array) ? opt[1] : opt)
+        }
+
+        selected_opt.is_a?(Array) ? selected_opt[0] : selected_opt
+      else
+        options[:input_html]&.has_key?(:value) ? options[:value] : @object.send(method)
+      end
+    end
+
+    def _transform_options(options, method)
+      options.deep_symbolize_keys!
+
+      options = _defaults.merge(options)
+
+      options[:label] = options.has_key?(:label) ? options[:label] : method.to_s.titleize
+
+      options[:field_wrapper_html] ||= {}
+      options[:label_wrapper_html] ||= {}
+      options[:label_html] ||= {}
+      options[:input_wrapper_html] ||= {}
+      options[:input_html] ||= {}
+
+      ### Shortcuts for some input_html arguments
+      [:value, :name].each do |key|
+        if options.has_key?(key) && !options[:input_html].has_key?(key)
+          options[:input_html][key] = options[key]
+        end
+      end
+
+      options[:field_wrapper_html][:class] ||= ""
+      options[:field_wrapper_html][:class].concat(" form-group").strip!
+
+      if !options.has_key?(:field_layout)
+        options[:field_layout] = :vertical
+      end
+      options[:field_layout] = options[:field_layout].to_sym
+
+      options[:required] = options.has_key?(:required) ? options[:required] : _attr_presence_required?(method)
+
+      options[:required_text] ||= "*"
+
+      options[:field_wrapper_html][:class].concat(" #{method}_field").strip!
+
+      if method && !options.has_key?(:errors)
+        options[:errors] = @object.errors[method]
+      end
+
+      if options[:errors].present?
+        options[:input_html][:class] ||= ""
+        options[:input_html][:class].concat(" is-invalid")
+      end
+
+      options
+    end
+
+    def _transform_select_options(options, method)
+      if !options.has_key?(:selected)
+        if options[:input_html].has_key?(:value)
+          options[:selected] = options[:input_html].delete(:value)
+        else
+          options[:selected] = object.send(method)
+        end
+      end
+
+      if options[:disabled].is_a?(TrueClass) && !options[:input_html].has_key?(:disabled)
+        options.delete(:disabled)
+        options[:input_html][:disabled] = true
+      end
+
+      options
+    end
+
+    def _transform_checkbox_options(options, method)
+      if options[:input_html].has_key?(:value) && !options[:input_html].has_key?(:checked)
+        options[:input_html][:checked] = (object.send(method) == options[:input_html][:value])
+      elsif @object.class.respond_to?(:columns_hash) && @object.class.columns_hash[method]&.type == :boolean
+        if !options[:input_html].has_key?(:checked)
+          if options[:input_html].has_key?(:value)
+            options[:input_html][:checked] = (options[:input_html][:value] == true)
+          else
+            options[:input_html][:checked] = (object.send(method) == true)
+          end
+        end
+
+        if !options[:input_html].has_key?(:value)
+          options[:input_html][:value] = "1"
+        end
+      end
+
+      options
+    end
+
+  end
+end

data/app/jobs/rails_i18n_manager/application_job.rb

@@ -0,0 +1,5 @@
+module RailsI18nManager
+  class ApplicationJob < ActiveJob::Base
+    self.queue_adapter = :async
+  end
+end

data/app/jobs/rails_i18n_manager/translations_import_job.rb

@@ -0,0 +1,70 @@
+module RailsI18nManager
+  class TranslationsImportJob < ApplicationJob
+
+    class ImportAbortedError < StandardError; end
+
+    def perform(translation_app_id:, import_file:, overwrite_existing: false, mark_inactive_translations: false)
+      app_record = TranslationApp.find(translation_app_id)
+
+      if import_file.end_with?(".json")
+        translations_hash = JSON.parse(File.read(import_file))
+      else
+        translations_hash = YAML.safe_load(File.read(import_file))
+      end
+
+      new_locales = translations_hash.keys - app_record.all_locales
+
+      if new_locales.any?
+        raise ImportAbortedError.new("Import aborted. Locale not listed in translation app: #{new_locales.join(', ')}")
+      end
+
+      all_keys = RailsI18nManager.fetch_flattened_dot_notation_keys(translations_hash)
+
+      key_records_by_key = app_record.translation_keys.includes(:translation_values).index_by(&:key)
+
+      all_keys.each do |key|
+        if key_records_by_key[key].nil?
+          key_records_by_key[key] = app_record.translation_keys.new(key: key)
+          key_records_by_key[key].save!
+        end
+      end
+
+      translation_values_to_import = []
+
+      key_records_by_key.each do |key, key_record|
+        app_record.all_locales.each do |locale|
+          split_keys = [locale] + key.split(".").map{|x| x}
+
+          val = translations_hash.dig(*split_keys)
+
+          if val.present?
+            val_record = key_record.translation_values.detect{|x| x.locale == locale.to_s }
+
+            if val_record.nil?
+              translation_values_to_import << key_record.translation_values.new(locale: locale, translation: val)
+            elsif val_record.translation.blank? || (overwrite_existing && val_record.translation != val)
+              val_record.update!(translation: val)
+              next
+            end
+          end
+        end
+      end
+
+      ### We use active_record-import for big speedup, set validate false if more speed required
+      TranslationValue.import(translation_values_to_import, validate: true)
+
+      if mark_inactive_translations
+        app_record.translation_keys
+          .where.not(key: all_keys)
+          .update_all(active: false)
+
+        app_record.translation_keys
+          .where(key: all_keys)
+          .update_all(active: true)
+      end
+
+      return true
+    end
+
+  end
+end

data/app/lib/rails_i18n_manager/forms/base.rb

@@ -0,0 +1,25 @@
+module RailsI18nManager
+  module Forms
+    class Base
+      include ActiveModel::Validations
+
+      def initialize(attrs={})
+        attrs ||= {}
+
+        attrs.each do |k,v|
+          self.send("#{k}=", v) ### Use send so that it checks that attr_accessor has already defined the method so its a valid attribute
+        end
+      end
+
+      def to_key
+        nil
+      end
+
+      def model_name
+        sanitized_class_name = self.class.name.to_s.gsub("Forms::", '').gsub(/Form$/, '')
+        ActiveModel::Name.new(self, self.class.superclass, sanitized_class_name)
+      end
+
+    end
+  end
+end

data/app/lib/rails_i18n_manager/forms/translation_file_form.rb

@@ -0,0 +1,55 @@
+module RailsI18nManager
+  module Forms
+    class TranslationFileForm < Base
+
+      attr_accessor :translation_app_id, :file, :overwrite_existing
+      attr_reader :overwrite_existing, :mark_inactive_translations
+
+      validates :translation_app_id, presence: {message: "Must select an App"}
+      validates :file, presence: true
+      validate :validate_file
+
+      def overwrite_existing=(val)
+        @overwrite_existing = ["1", "true", "t"].include?(val.to_s.downcase)
+      end
+
+      def mark_inactive_translations=(val)
+        @mark_inactive_translations = ["1", "true", "t"].include?(val.to_s.downcase)
+      end
+
+      def validate_file
+        if file.blank?
+          errors.add(:file, "Must upload a valid translation file.")
+          return
+        end
+
+        if [".yml", ".json"].exclude?(File.extname(file))
+          errors.add(:file, "Invalid file format. Must be yml or json file.")
+          return
+        end
+
+        if File.read(file).blank?
+          errors.add(:file, "Empty file provided.")
+          return
+        end
+
+        case File.extname(file)
+        when ".yml"
+          if !YAML.safe_load(File.read(file)).is_a?(Hash)
+            errors.add(:file, "Invalid yml file.")
+            return
+          end
+
+        when ".json"
+          begin
+            JSON.parse(File.read(file))
+          rescue JSON::ParserError
+            errors.add(:file, "Invalid json file.")
+            return
+          end
+        end
+      end
+
+    end
+  end
+end

data/app/lib/rails_i18n_manager/google_translate.rb

@@ -0,0 +1,72 @@
+module RailsI18nManager
+  module GoogleTranslate
+
+    def self.translate(text, from:, to:)
+      api_key = RailsI18nManager.config.google_translate_api_key
+
+      if !supported_locales.include?(to.to_s) || Rails.env.test? || (api_key.blank? && Rails.env.development?)
+        return false
+      end
+
+      if text.include?("<") && text.include?(">")
+        ### Dont translate any HTML strings
+        return nil
+      end
+
+      EasyTranslate.translate(text, from: from, to: to, key: api_key)
+
+      if translation
+        str = translation.to_s
+
+        if str.present?
+          ### Replace single quote html entity with single quote character
+          str = str.gsub("&#39;", "'")
+
+          if to.to_s == "es"
+            str = str.gsub("% {", " %{").strip
+          end
+
+          return str
+        end
+      end
+    end
+
+    ### List retrieved from Google Translate (2022)
+    @@supported_locales = ["af", "am", "ar", "az", "be", "bg", "bn", "bs", "ca", "ceb", "co", "cs", "cy", "da", "de", "el", "en", "eo", "es", "et", "eu", "fa", "fi", "fr", "fy", "ga", "gd", "gl", "gu", "ha", "haw", "he", "hi", "hmn", "hr", "ht", "hu", "hy", "id", "ig", "is", "it", "iw", "ja", "jw", "ka", "kk", "km", "kn", "ko", "ku", "ky", "la", "lb", "lo", "lt", "lv", "mg", "mi", "mk", "ml", "mn", "mr", "ms", "mt", "my", "ne", "nl", "no", "ny", "or", "pa", "pl", "ps", "pt", "ro", "ru", "rw", "sd", "si", "sk", "sl", "sm", "sn", "so", "sq", "sr", "st", "su", "sv", "sw", "ta", "te", "tg", "th", "tk", "tl", "tr", "tt", "ug", "uk", "ur", "uz", "vi", "xh", "yi", "yo", "zh", "zh-CN", "zh-TW", "zu"].freeze
+    mattr_reader :supported_locales
+
+    ### FOR official client
+    # require "google/cloud/translate/v2" ### Offical Google Translate with API Key
+    # def self.client
+    #   @@client ||= begin
+    #     api_key = RailsI18nManager.config.google_translate_api_key
+    #     if Rails.env.test? || (api_key.blank? && Rails.env.development?)
+    #       ### Skip Client
+    #       nil
+    #     else
+    #       Google::Cloud::Translate::V2.new(key: api_key)
+    #     end
+    #   end
+    # end
+    # def self.supported_locales
+    #   @@suported_locales ||= begin
+    #     if client
+    #       @@supported_locales = client.languages.map{|x| x.code}
+    #     else
+    #       []
+    #     end
+    #   end
+    # end
+    # def self.translate(text, from:, to:)
+    #   if client
+    #    begin
+    #       translation = client.translate(text, from: from, to: to)
+    #     rescue Google::Cloud::InvalidArgumentError
+    #       ### Error usually caused by an unsupported locale
+    #       return nil
+    #     end
+    #   end
+    # end
+
+  end
+end

data/app/models/rails_i18n_manager/application_record.rb

@@ -0,0 +1,20 @@
+module RailsI18nManager
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    include ActiveSortOrder
+
+    scope :multi_search, ->(full_str){ 
+      if full_str.present?
+        rel = self
+
+        full_str.split(' ').each do |q|
+          rel = rel.search(q)
+        end
+
+        next rel
+      end
+    }
+
+  end
+end

data/app/models/rails_i18n_manager/translation_app.rb

@@ -0,0 +1,108 @@
+module RailsI18nManager
+  class TranslationApp < ApplicationRecord
+    NAME = "Translated App".freeze
+
+    has_many :translation_keys, class_name: "RailsI18nManager::TranslationKey", dependent: :destroy
+
+    before_validation :clean_additional_locales
+    after_update :handle_removed_locales
+    after_update :handle_added_locales
+
+    validates :name, presence: true, uniqueness: {case_sensitive: false}
+    validates :default_locale, presence: true
+    validate :validate_additional_locales
+
+    scope :search, ->(str){
+      fields = [
+        "#{table_name}.name",
+      ]
+
+      like = connection.adapter_name.downcase.to_s == "postgres" ? "ILIKE" : "LIKE"
+
+      sql_conditions = []
+
+      fields.each do |col|
+        sql_conditions << "(#{col} #{like} :search)"
+      end
+
+      self.where(sql_conditions.join(" OR "), search: "%#{str}%")
+    }
+
+    def additional_locales=(val)
+      if val.is_a?(Array)
+        val = val.map{|x| x.to_s.downcase.strip.presence }.compact.uniq.sort
+        val.delete(self.default_locale)
+
+        self[:additional_locales] = val.join(",")
+      else
+        self[:additional_locales] = val
+      end
+    end
+
+    def additional_locales_array
+      additional_locales.to_s.split(",")
+    end
+
+    def all_locales
+      [self.default_locale] + additional_locales_array
+    end
+
+    private
+
+    def validate_additional_locales
+      if additional_locales_changed?
+        invalid_locales = []
+
+        additional_locales_array.each do |locale|
+          if !RailsI18nManager.config.valid_locales.include?(locale)
+            invalid_locales << locale
+          end
+        end
+
+        if invalid_locales.any?
+          self.errors.add(:additional_locales, "Invalid locales: #{invalid_locales.join(", ")}")
+        end
+      end
+    end
+
+    def clean_additional_locales
+      if additional_locales_changed?
+        cleaned_array = additional_locales_array.map{|x| x.to_s.downcase.strip.presence }.compact.uniq.sort
+        cleaned_array.delete(self.default_locale)
+
+        self.additional_locales = cleaned_array.join(",")
+      end
+    end
+
+    def handle_removed_locales
+      if previous_changes.has_key?("default_locale") || previous_changes.has_key?("additional_locales")
+        TranslationValue
+          .joins(:translation_key).where(TranslationKey.table_name => {translation_app_id: self.id})
+          .where.not(locale: all_locales)
+          .delete_all ### instead of destroy_all, use delete_all for speedup
+      end
+    end
+
+    def handle_added_locales
+      ### ATTEMPTING TO JUST SKIP THIS
+
+      # ### For new locales, create TranslationValue records
+      # value_records_for_import = []
+
+      # translation_keys.includes(:translation_values).each do |key_record|
+      #   additional_locales_array.each do |locale|
+      #     val_record = key_record.translation_values.detect{|x| x.locale == locale }
+
+      #     if val_record.nil?
+      #       value_records_for_import << key_record.translation_values.new(locale: locale)
+      #     end
+      #   end
+      # end
+
+      # ### We use active_record-import for big speedup also using validate: false for more speed
+      # TranslationValue.import(value_records_for_import, validate: false)
+      # end
+    end
+
+  end
+end