RubyGems - lesli_babel - Versions diffs - 0.4.0 → 0.6.0 - Mend

lesli_babel 0.4.0 → 0.6.0

Files changed (33) hide show

data/app/models/lesli_babel/string/activity.rb DELETED Viewed

@@ -1,5 +0,0 @@
-module LesliBabel
-    class String::Activity < CloudObject::Activity
-        belongs_to :cloud_object, class_name: "String", foreign_key: "cloud_babel_strings_id", optional: true
-    end
-end

data/app/models/lesli_babel/string/discussion.rb DELETED Viewed

@@ -1,68 +0,0 @@
-module LesliBabel
-    class String::Discussion < CloudObject::Discussion
-        belongs_to :cloud_object, class_name: "String", foreign_key: "cloud_babel_strings_id"
-        belongs_to :parent, class_name: "Discussion", optional: true
-        has_many :children, class_name: "Discussion", foreign_key: "parent_id"
-        def self.list(current_user, cloud_id)
-            discussions = self.joins(
-                "inner join cloud_babel_strings CO on cloud_babel_string_discussions.cloud_babel_strings_id = CO.id"
-            ).joins(
-                "inner join users U on cloud_babel_string_discussions.users_id = U.id"
-            ).joins(
-                "inner join user_details UD on UD.users_id = U.id"
-            ).select(
-                "cloud_babel_string_discussions.id",
-                "cloud_babel_string_discussions.users_id",
-                "cloud_babel_string_discussions.content",
-                "cloud_babel_string_discussions.created_at",
-                "cloud_babel_string_discussions.cloud_babel_string_discussions_id",
-                "U.email",
-                "CONCAT(UD.first_name, ' ', UD.last_name) as user_name"
-            )
-            .where("CO.id = #{cloud_id}")
-            .where("CO.reference_module_bucket LIKE ?", "#{Rails.configuration.lesli_settings["instance"]}%")
-            .order(id: :asc)
-            .map { |discussion|
-                discussion_attributes = discussion.attributes
-                discussion_attributes["created_at_raw"] = discussion_attributes["created_at"]
-                discussion_attributes["editable"] = discussion.is_editable_by?(current_user)
-                discussion_attributes["created_at"] = LC::Date.to_string_datetime(discussion_attributes["created_at"])
-                discussion_attributes
-            }
-            data = {}
-            root_discussions = []
-            # Add all responses to that discussion
-            discussions.each do |discussion|
-                discussion_data = {
-                    data: discussion,
-                    responses: []
-                }
-                data[discussion["id"]] = discussion_data
-                if discussion["cloud_babel_string_discussions_id"].present?
-                    parent_discussion = data[discussion["cloud_babel_string_discussions_id"]]
-                    if parent_discussion[:data]["cloud_babel_string_discussions_id"].present?
-                        discussion["response_to"] = parent_discussion[:data]["email"]
-                    end
-                    parent_discussion[:responses].push(discussion["id"])
-                else
-                    root_discussions.push(discussion_data)
-                end
-            end
-            # Nest the responses to root discussions. A root discussion is any comment that is not a response to another comment
-            root_discussions.each do |discussion|
-                responses = []
-                self.nest_responses(data, discussion, responses)
-                discussion[:responses] = responses
-            end
-            # revert the root discussions so the most recent comments appear in the top
-            root_discussions.reverse
-        end
-    end
-end

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

@@ -1,82 +0,0 @@
-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 DELETED Viewed

@@ -1,161 +0,0 @@
-=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 DELETED Viewed

@@ -1,102 +0,0 @@
-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 DELETED Viewed

@@ -1,119 +0,0 @@
-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 DELETED Viewed

@@ -1,114 +0,0 @@
-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