lesli_babel 0.1.0

data/app/services/lesli_babel/old/translations_android_service.rb

@@ -0,0 +1,82 @@
+module LesliBabel
+    class TranslationsAndroidService
+
+        def self.build(engine_id = nil)
+
+            translation_folder_path = Rails.root.join("public", "tmp", "locales")
+
+            # get all rails engines
+            engines = Module.where(:id => engine_id).map do |engine|
+                engine[:id]
+            end
+
+            # get strings filtered by module (only rails translations)
+            strings = TranslationsService.strings_for_apps(engines)
+
+            translations = {}
+
+            available_locales = Rails.application.config.lesli_settings["configuration"]["locales"]
+
+            strings.each do |string|
+
+                module_name = string[:engine_name].downcase.sub("cloud", "")
+                engine_name = string[:engine_name]
+                bucket_name = string[:bucket_name]
+                module_type = string[:platform]
+
+                available_locales.each do |lang|
+
+                    file_path = translation_folder_path.join(
+                        engine_name, "values-#{lang}", "#{ bucket_name.gsub("/","_") }.xml"
+                    )
+
+                    file_id = file_path.to_s
+
+                    unless translations.has_key? file_id
+                        translations[file_id] = []
+                    end
+
+                    # send debug message for missing translations
+                    string[lang] = ":" + string.path + ":" if string[lang].blank?
+
+                    translations[file_id].push({
+                        label: string.label, 
+                        translation: string[lang]
+                    })
+
+                end
+
+            end
+
+            translation_files = []
+
+            translations.each do |translation|
+
+                file_path = translation[0]
+                strings = translation[1]
+
+                translation_files.push(file_path)
+
+                # creates folder and subfolders
+                FileUtils.makedirs(File.dirname(file_path))
+
+                # creates translation file for every available language
+                translation_file = File.new(file_path, "w+")
+
+                translation_file.write("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+                translation_file.write("<resources>\n")
+                strings.each do |string|
+                    translation_file.write("<string name=\"#{string[:label]}\">#{string[:translation]}</string>\n")
+                end
+                translation_file.write("</resources>")
+
+                translation_file.close
+
+            end
+
+            LC::Response.service true, translation_files
+
+        end
+
+    end
+end

data/app/services/lesli_babel/old/translations_clone_service.rb

@@ -0,0 +1,161 @@
+=begin
+
+Copyright (c) 2020, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+
+=end
+
+module LesliBabel
+    class TranslationsCloneService
+
+
+        # IMPORTANT: This is a modified copy of the SynchronizationService
+        # please be careful modifying this file
+        def self.remote_clone instance_code=nil
+
+            instance_name = instance_code.camelize
+            instance_code = instance_code.gsub("_","-")
+
+
+            # synchronization server url
+            host = "http://localhost:8080"
+            host = "https://server.raven.dev.gt"
+
+
+            return LC::Response.service(false, "no valid instance code provided") if instance_code.blank?
+
+
+            api_endpoint = "#{host}/api/bucket/babel-#{instance_code}/documents"
+
+
+            # get last sync data
+            response = Faraday.get(api_endpoint+"?last=1")
+            response = FastJsonparser.parse(response.body)
+            response = response[:data][:documents][0]
+
+
+            # if first time sync
+            return LC::Response.service(false, "no strings found") if response.blank?
+
+
+            # add new modules
+            response[:modules].each do |babel_module|
+                next if babel_module[:name].blank?
+
+                # we do not want to clone strings from builder engines
+                next if babel_module[:name] == instance_name
+
+                platform = babel_module[:platform]
+                platform = "rails_engine"   if babel_module[:name].start_with?("Cloud")
+                platform = "rails_core"     if babel_module[:name] == "Core"
+
+                local_module = CloudBabel::Module
+                .create_with({
+                    created_at: babel_module[:created_at],
+                    platform: babel_module[:platform]
+                }).find_or_create_by({ name: babel_module[:name] })
+
+                local_module.platform = platform
+                local_module.updated_at = DateTime.now
+                local_module.save
+
+            end
+
+            # working with buckets
+            babel_reference_modules = {}
+
+            response[:buckets].each do |babel_bucket|
+
+                next if babel_bucket[:name].blank?
+
+                # we do not want to clone strings from builder engines
+                next if babel_bucket[:reference_module] == instance_name
+
+                # reference to modules that buckets belongs to
+                # this reference as string is necessary because the id of the module can change
+                # between synchronizations, thats why we search for the id of the module every time
+                if babel_reference_modules[babel_bucket[:reference_module]].blank?
+                    babel_reference_modules[babel_bucket[:reference_module]] =
+                    CloudBabel::Module.find_by(name: babel_bucket[:reference_module])
+                end
+
+                # add new bucket
+                CloudBabel::Bucket
+                .create_with({
+                    created_at: babel_bucket[:created_at],
+                    module: babel_reference_modules[babel_bucket[:reference_module]]
+                }).find_or_create_by({
+                    name: babel_bucket[:name],
+                    reference_module: babel_bucket[:reference_module]
+                })
+
+            end
+
+            # · working with strings
+            babel_reference_buckets = {}
+
+            response[:strings].each do |remote_string|
+                # reference to modules that buckets belongs to
+                # this reference as string is necessary because the id of the module or bucket can change
+                # between synchronizations, thats why we search for the id of the module every time
+                if babel_reference_buckets[remote_string[:reference_bucket]].blank?
+                    remote_string[:reference_bucket] ||= remote_string[:reference_module_bucket]
+                    babel_reference_buckets[remote_string[:reference_bucket]] = 
+                    CloudBabel::Bucket.find_by(
+                        name: remote_string[:reference_bucket].split("-")[1],
+                        reference_module: remote_string[:reference_bucket].split("-")[0]
+                    )
+                end
+
+                # Do not sync labes that do not have a valid module and bucket reference
+                next if babel_reference_buckets[remote_string[:reference_bucket]].blank?
+
+                # we do not want to clone strings from builder engines
+                next if babel_reference_buckets[remote_string[:reference_bucket]].reference_module == instance_name
+            
+                remote_string_reference = "#{babel_reference_buckets[remote_string[:reference_bucket]].reference_module}-#{babel_reference_buckets[remote_string[:reference_bucket]].name}"
+
+                # add new string if it does not exist
+                local_string = CloudBabel::String.with_deleted.create_with({
+                    context: remote_string[:context],
+                    es: remote_string[:es],
+                    en: remote_string[:en],
+                    de: remote_string[:de],
+                    status: remote_string[:status],
+                    need_help: remote_string[:need_help],
+                    need_translation: remote_string[:need_translation],
+                    last_update_context: remote_string[:last_update_context],
+                    last_update_es: remote_string[:last_update_es],
+                    last_update_en: remote_string[:last_update_en],
+                    last_update_de: remote_string[:last_update_de],
+                    last_update_fr: remote_string[:last_update_fr],
+                    last_update_status: remote_string[:last_update_status],
+                    created_at: remote_string[:created_at],
+                    updated_at: remote_string[:updated_at],
+                    deleted_at: remote_string[:deleted_at],
+                    bucket: babel_reference_buckets[remote_string[:reference_bucket]]
+                }).find_or_create_by({
+                    label: remote_string[:label],
+                    reference_module_bucket: remote_string_reference
+                })
+
+            end
+
+            LC::Response.service true
+
+        end
+
+    end
+end

data/app/services/lesli_babel/old/translations_flutter_service.rb

@@ -0,0 +1,102 @@
+module LesliBabel
+    class TranslationsFlutterService
+
+        def self.build(engine_id = nil)
+
+            # get all rails engines
+            engines = Module.where(:id => engine_id).map do |engine|
+                engine[:id]
+            end
+
+            # get strings filtered by module (only rails translations)
+            strings = TranslationsService.strings_for_apps(engines)
+
+            indexes = {}
+            translations = {}
+            available_locales = Rails.application.config.lesli_settings["configuration"]["locales"]
+
+            strings.each do |string|
+
+                module_name = string[:engine_name].downcase.sub("cloud", "")
+                engine_name = string[:engine_name]
+                bucket_name = string[:bucket_name]
+                module_type = string[:platform]
+                
+                bucket_name_clean = bucket_name.gsub("/","_")
+
+                available_locales.each do |lang|
+
+                    file_path = Rails.root.join(
+                        "public", "tmp", "babel", "flutter","l10n", "app_#{lang}.arb"
+                    )
+
+                    file_id = file_path.to_s
+
+                    unless translations.has_key? file_id
+                        translations[file_id] = []
+                    end
+
+                    # send debug message for missing translations
+                    string[lang] = ":" + string.path + ":" if string[lang].blank?
+
+                    translations[file_id].push({
+                        label: "#{bucket_name_clean}_#{string.label}".camelize(:lower), 
+                        translation: string[lang]
+                    })
+
+                end
+
+                # Index keys
+                if not indexes.has_key? bucket_name_clean
+                    indexes[bucket_name_clean] = []
+                end
+
+                indexes[bucket_name_clean].push({
+                    k: string.label.camelize(:lower),
+                    v: "#{bucket_name_clean}_#{string.label}".upcase
+                })
+
+            end
+
+            translation_files = []
+
+            # Create translations files for every available language
+            translations.each do |translation|
+
+                file_path = translation[0]
+                strings = translation[1]
+
+                translation_files.push(file_path)
+
+                # creates folder and subfolders
+                FileUtils.makedirs(File.dirname(file_path))
+
+                # creates translation file for every available language
+                translation_file = File.new(file_path, "w+")
+
+                # start the file with curlybraces as flutter requires
+                translation_file.write("{\n")
+
+                strings.each_with_index do |string,index|
+
+                    # writes the key value translations
+                    translation_file.write("\"#{string[:label]}\": \"#{string[:translation]}\"")
+
+                    # add comma and new line if not last string
+                    translation_file.write(",\n") if index != strings.size - 1
+
+                end
+
+                # ends the file with curlybraces
+                translation_file.write("}\n")
+
+                translation_file.close
+
+            end
+
+            LC::Response.service true, translation_files
+
+        end
+
+    end
+end

data/app/services/lesli_babel/old/translations_ios_service.rb

@@ -0,0 +1,119 @@
+module LesliBabel
+    class TranslationsIosService
+
+        def self.build(engine_id = nil)
+
+            # get all rails engines
+            engines = Module.where(:id => engine_id).map do |engine|
+                engine[:id]
+            end
+
+            # get strings filtered by module (only rails translations)
+            strings = TranslationsService.strings_for_apps(engines)
+
+            indexes = {}
+            translations = {}
+
+            available_locales = Rails.application.config.lesli_settings["configuration"]["locales"]
+
+            strings.each do |string|
+
+                module_name = string[:engine_name].downcase.sub("cloud", "")
+                engine_name = string[:engine_name]
+                bucket_name = string[:bucket_name]
+                module_type = string[:platform]
+                bucket_name_clean = bucket_name.gsub("/","_")
+
+                available_locales.each do |lang|
+
+                    file_path = Rails.root.join(
+                        "public", "tmp", "locales", engine_name, "Resources",
+                        "#{lang}.lproj", "Localizable.strings"
+                    )
+
+                    file_id = file_path.to_s
+
+                    unless translations.has_key? file_id
+                        translations[file_id] = []
+                    end
+
+                    # send debug message for missing translations
+                    string[lang] = ":" + string.path + ":" if string[lang].blank?
+
+                    translations[file_id].push({
+                        label: "#{bucket_name_clean}_#{string.label}".upcase, 
+                        translation: string[lang]
+                    })
+
+                end
+
+                # Index keys
+                if not indexes.has_key? bucket_name_clean
+                    indexes[bucket_name_clean] = []
+                end
+
+                indexes[bucket_name_clean].push({
+                    k: string.label.camelize(:lower),
+                    v: "#{bucket_name_clean}_#{string.label}".upcase
+                })
+
+            end
+
+            translation_files = []
+
+            # Create translations files for every available language
+            translations.each do |translation|
+
+                file_path = translation[0]
+                strings = translation[1]
+
+                translation_files.push(file_path)
+
+                # creates folder and subfolders
+                FileUtils.makedirs(File.dirname(file_path))
+
+                # creates translation file for every available language
+                translation_file = File.new(file_path, "w+")
+
+                strings.each do |string|
+                    translation_file.write("\"#{string[:label]}\" = \"#{string[:translation]}\";\n")
+                end
+
+                translation_file.close
+
+            end
+
+            # Create global label index file
+            index_file_path = Rails.root.join("public", "tmp", "locales", "Translations.swift")
+
+            FileUtils.makedirs(File.dirname(index_file_path))
+
+            index_file = File.new(index_file_path, "w+")
+
+            index_file.write("\ enum Translations { \n")
+
+            indexes.each do |index_bucket|
+
+                index_file.write("\ enum #{index_bucket[0]} { \n")
+
+                index_bucket[1].each do |index_label|
+                    index_file.write("static let #{index_label[:k]} = \"#{index_label[:v]}\"\n")
+                end
+
+                index_file.write("\ } \n")
+
+            end
+
+            index_file.write("\ } \n")
+
+            index_file.close
+
+            # include index into translation files zip
+            translation_files.push(index_file_path)
+
+            LC::Response.service true, translation_files
+
+        end
+
+    end
+end

data/app/services/lesli_babel/old/translations_js_service.rb

@@ -0,0 +1,114 @@
+module LesliBabel
+    class TranslationsJsService
+
+        def self.build
+
+            # usually we download translations to use with other platforms like, flutter, reactnative, electron etc.
+            # so for these cases we need to include all the translations 
+            engines = Module.all.map do |engine|
+                engine[:id]
+            end
+
+            # get strings filtered by module (only rails translations)
+            strings = TranslationsService.strings(engines)
+
+            strings = strings.select(
+                :id,
+                :label,
+                :status,
+                :context,
+                :priority,
+                :need_help,
+                :need_translation,
+                Rails.application.config.lesli_settings["configuration"]["locales"],
+                "cloud_babel_modules.id as engine_id",
+                "cloud_babel_buckets.id as bucket_id",
+                "cloud_babel_buckets.name as bucket_name",
+                "cloud_babel_modules.name as engine_name",
+                "cloud_babel_modules.platform as platform",
+                "'' as path"
+            )
+
+            translations = {}
+
+            available_locales = Rails.application.config.lesli_settings["configuration"]["locales"]
+
+            # add key for every available language (required by i18n Rails gem)
+            available_locales.each do |lang|
+                translations[lang] = { }
+            end
+
+            strings.each do |string|
+                module_name = string[:engine_name].downcase.sub("cloud", "")
+                engine_code = string[:engine_name].underscore
+                engine_name = string[:engine_name]
+                bucket_name = string[:bucket_name]
+                platform = string[:platform]
+
+                available_locales.each do |lang|
+
+                    # translations path for lesli core
+                    file_path = Rails.root.join("config", "locales", bucket_name, "#{ bucket_name.gsub("/","_") }.#{ lang }.js")
+
+                    # translations path for translations for engines
+                    file_path = Rails.root.join("public", "tmp", "locales", "#{lang}.json")
+
+                    file_id = file_path.to_s.to_sym
+
+                    unless translations[lang].has_key? file_id
+                        translations[lang][file_id] = { }
+                    end
+
+                    unless translations[lang][file_id].has_key? module_name
+                        translations[lang][file_id][module_name] = { }
+                    end
+
+                    unless translations[lang][file_id][module_name].has_key? bucket_name
+                        translations[lang][file_id][module_name][bucket_name] = { }
+                    end
+
+                    # send debug message for missing translations
+                    #string[lang] = ":" + string.path + ":" if string[lang].blank?
+
+                    translations[lang][file_id][module_name][bucket_name][string.label] = string[lang]
+
+                end
+
+            end
+
+            translation_files = []
+
+            translations.each do |file_by_language|
+
+                lang = file_by_language[0]
+                file_by_controller = file_by_language[1]
+
+                file_by_controller.each do |file|
+
+                    file_path = file[0].to_s
+                    translations = file[1]
+
+                    translation_files.push(file_path)
+
+                    # creates folder and subfolders
+                    FileUtils.makedirs(File.dirname(file_path))
+
+                    # creates translation file for every available language
+                    translation_file = File.new(file_path, "w+")
+
+                    translation_file.write({ "#{lang}": translations}.to_json)
+
+                    translation_file.close
+
+                    p "file added: #{ file_path }"
+
+                end
+
+            end
+
+            LC::Response.service true, translation_files
+
+        end
+
+    end
+end

data/app/services/lesli_babel/old/translations_middleman_service.rb

@@ -0,0 +1,77 @@
+module LesliBabel
+    class TranslationsMiddlemanService
+
+        def self.build(engine_id)
+
+            # get all rails engines
+            engines = Module.where(:id => engine_id).map(&:id)
+            
+            # get strings filtered by module (only rails translations)
+            strings = TranslationsService.strings_for_apps(engines)
+
+            indexes = {}
+            translations = {}
+            available_locales = Rails.application.config.lesli_settings["configuration"]["locales"]
+
+            # add key for every available language (required by i18n Rails gem)
+            available_locales.each do |lang|
+                translations[lang] = { :path => '', :labels => {} }
+            end
+
+            strings.each do |string|
+
+                module_name = string[:engine_name].downcase.sub("cloud", "")
+                engine_name = string[:engine_name]
+                bucket_name = string[:bucket_name]
+                module_type = string[:platform]
+                
+                bucket_name_clean = bucket_name.gsub("/","_")
+
+                available_locales.each do |lang|
+
+                    file_path = Rails.root.join(
+                        "public", "tmp", "babel", "middleman","locales", "#{lang}.yml"
+                    )
+
+                    translations[lang][:file] = file_path.to_s
+
+                    unless translations[lang][:labels].has_key? bucket_name
+                        translations[lang][:labels][bucket_name] = { }
+                    end
+
+                    # send debug message for missing translations
+                    string[lang] = ":" + string.path + ":" if string[lang].blank?
+
+                    translations[lang][:labels][bucket_name][string.label] = string[lang]
+
+                end
+
+            end
+
+            translation_files = []
+
+            # Create translations files for every available language
+            translations.each do |translation|
+
+                lang = translation[0]
+                file = translation[1][:file]
+                labels = translation[1][:labels]
+                
+                translation_files.push(file)
+
+                # creates folder and subfolders
+                FileUtils.makedirs(File.dirname(file))
+
+                # creates translation file for every available language
+                translation_file = File.new(file, "w+")
+                translation_file.write({ "#{lang.to_s}": labels}.to_yaml)
+                translation_file.close
+
+            end
+
+            LC::Response.service true, translation_files
+
+        end
+
+    end
+end