ad_localize 3.6.0 → 4.0.0

data/lib/ad_localize/csv_parser.rb

@@ -1,165 +0,0 @@
-module AdLocalize
-  class CsvParser
-    CSV_WORDING_KEYS_COLUMN = "key"
-    PLURAL_KEY_REGEXP = /\#\#\{([A-Za-z]+)\}/
-    ADAPTIVE_KEY_REGEXP = /\#\#\{(\d+)\}/
-    INFO_PLIST_KEY_REGEXP = /(NS.+UsageDescription)|(CF.+Name)/ # see https://developer.apple.com/documentation/bundleresources/information_property_list
-
-    attr_accessor :locales
-
-    def initialize
-      @locales = []
-    end
-
-    # Raise a StandardError if no locale is detected in the csv
-    def extract_data(file_name)
-      data = {}
-      CSV.foreach(file_name, headers: true, skip_blanks: true) do |row|
-        validity_status = check_row(row)
-        if validity_status.zero?
-          keys_column_index = row.index(CSV_WORDING_KEYS_COLUMN)
-          fields = row.fields
-          LOGGER.log(:warn, :yellow, "Missing key in line #{$.}") unless fields[keys_column_index...fields.count].all?(&:nil?)
-          next
-        elsif validity_status == -1
-          LOGGER.log(:error, :red, "[CSV FORMAT] #{file_name} is not a valid file")
-          exit
-        else
-          find_locales(row) if locales.empty?
-          row_data = parse_row(row)
-          data.deep_merge!(row_data) unless row_data.nil?
-        end
-      end
-      remove_numeral_conflicts!(data)
-      data
-    end
-
-    private
-
-    # Returns 1 if row is ok, 0 if row there are missing information and -1 if row is not a csv row
-    def check_row(row)
-      valid_row = 1
-      # Check non empty row
-      if row.field(CSV_WORDING_KEYS_COLUMN).nil?
-        valid_row = 0
-      elsif not row.headers.include?(CSV_WORDING_KEYS_COLUMN)
-        valid_row = -1
-      end
-      return valid_row
-    end
-
-    def find_locales(row)
-      wording_key_column_index = row.index(CSV_WORDING_KEYS_COLUMN)
-      if row.length > wording_key_column_index
-        self.locales = row.headers.slice((wording_key_column_index+1)..-1).compact.reject do |header|
-          header.to_s.include? Constant::COMMENT_KEY_COLUMN_IDENTIFIER
-        end
-      end
-      if locales.empty?
-        raise 'NO DETECTED LOCALES'
-      else
-        LOGGER.log(:debug, :green, "DETECTED LOCALES : #{locales.join(', ')}")
-      end
-    end
-
-    def parse_row(row)
-      key_infos = parse_key(row)
-      return nil if key_infos.nil?
-
-      locales.each_with_object({ key_infos.dig(:key) => {} }) do |locale, output|
-        current_key = key_infos.dig(:key)
-        current_key_already_has_wording_for_locale = output[current_key].key? locale.to_sym
-        output[current_key][locale.to_sym] = { key_infos.dig(:numeral_key) => {} } unless current_key_already_has_wording_for_locale
-
-        if key_infos.dig(:numeral_key) == Constant::SINGULAR_KEY_SYMBOL
-          trace_wording(row[locale], "[#{locale.upcase}] Singular key ---> #{current_key}", "[#{locale.upcase}] Missing translation for #{current_key}")
-          value = row[locale] || default_wording(locale, current_key)
-        elsif key_infos.dig(:numeral_key) == Constant::PLURAL_KEY_SYMBOL
-          trace_wording(row[locale],
-            "[#{locale.upcase}] Plural key ---> plural_identifier : #{key_infos.dig(:plural_identifier)}, key : #{current_key}",
-            "[#{locale.upcase}] Missing translation for #{current_key} (#{key_infos.dig(:plural_identifier)})")
-          value = { key_infos.dig(:plural_identifier) => row[locale] || default_wording(locale, "#{current_key} (#{key_infos.dig(:plural_identifier)})") }
-        elsif key_infos.dig(:numeral_key) == Constant::ADAPTIVE_KEY_SYMBOL
-          trace_wording(row[locale],
-            "[#{locale.upcase}] Adaptive key ---> adaptive_identifier : #{key_infos.dig(:adaptive_identifier)}, key : #{current_key}",
-            "[#{locale.upcase}] Missing translation for #{current_key} (#{key_infos.dig(:adaptive_identifier)})")
-          value = { key_infos.dig(:adaptive_identifier) => row[locale] || default_wording(locale, "#{current_key} (#{key_infos.dig(:adaptive_identifier)})") }
-        elsif key_infos.dig(:numeral_key) == Constant::INFO_PLIST_KEY_SYMBOL
-          trace_wording(row[locale], "[#{locale.upcase}] Info.plist key ---> #{current_key}", "[#{locale.upcase}] Missing translation for #{current_key}")
-          value = row[locale] || default_wording(locale, current_key)
-        else
-          raise "Unknown numeral key #{key_infos.dig(:numeral_key)}"
-        end
-
-        check_wording_parameters(row[locale], locale, current_key)
-        output[current_key][locale.to_sym][key_infos.dig(:numeral_key)] = value
-        locale_comment_column = "#{Constant::COMMENT_KEY_COLUMN_IDENTIFIER} #{locale}"
-        output[current_key][locale.to_sym][Constant::COMMENT_KEY_SYMBOL] = row[locale_comment_column] unless locale_comment_column.blank? and row[locale_comment_column].blank?
-      end
-    end
-
-    def parse_key(row)
-      key = row.field(CSV_WORDING_KEYS_COLUMN).strip
-      plural_prefix = key.match(PLURAL_KEY_REGEXP)
-      plural_identifier = nil
-      invalid_plural = false
-
-      adaptive_prefix = key.match(ADAPTIVE_KEY_REGEXP)
-      adaptive_identifier = nil
-      invalid_adaptive = false
-
-      if plural_prefix != nil
-        numeral_key = Constant::PLURAL_KEY_SYMBOL
-        key = plural_prefix.pre_match
-        plural_identifier = plural_prefix.captures&.first
-        LOGGER.log(:debug, :red, "Invalid key #{key}") if key.nil?
-        LOGGER.log(:debug, :red, "Empty plural prefix!") if plural_identifier.nil?
-        invalid_plural = plural_identifier.nil?
-      elsif adaptive_prefix != nil
-        numeral_key = Constant::ADAPTIVE_KEY_SYMBOL
-        key = adaptive_prefix.pre_match
-        adaptive_identifier = adaptive_prefix.captures&.first
-        LOGGER.log(:debug, :red, "Invalid key #{key}") if key.nil?
-        LOGGER.log(:debug, :red, "Empty adaptive prefix!") if adaptive_identifier.nil?
-        invalid_adaptive = adaptive_identifier.nil?
-      elsif key.match(INFO_PLIST_KEY_REGEXP) != nil
-        numeral_key = Constant::INFO_PLIST_KEY_SYMBOL
-      else
-        numeral_key = Constant::SINGULAR_KEY_SYMBOL
-      end
-
-      (key.nil? or invalid_plural or invalid_adaptive) ? nil : { key: key.to_sym, numeral_key: numeral_key, plural_identifier: plural_identifier&.to_sym, adaptive_identifier: adaptive_identifier&.to_sym }
-    end
-
-    def default_wording(locale, key)
-      LOGGER.debug? ? "<[#{locale.upcase}] Missing translation for #{key}>" : ""
-    end
-
-    def trace_wording(wording, present_message, missing_message)
-      if wording
-        LOGGER.log(:debug, :green, present_message)
-      else
-        LOGGER.log(:debug, :yellow, missing_message)
-      end
-    end
-
-    def check_wording_parameters(value, locale, key)
-      formatted_arguments = value&.scan(/%(\d$)?@/) || []
-      if formatted_arguments.size >= 2
-        is_all_ordered = formatted_arguments.inject(true){ |is_ordered, match| is_ordered &&= !match.join.empty? }
-        LOGGER.log(:warn, :red, "[#{locale.upcase}] Multiple arguments for #{key} but no order") unless is_all_ordered
-      end
-    end
-
-    def remove_numeral_conflicts!(data)
-      data.select do |_, wording|
-        wording.values.any? { |translation| (translation.keys & [:plural, :singular]).size == 2 }
-      end.keys.each do |key|
-        AdLocalize::LOGGER.log(:warn, :yellow, "Key \"#{key}\" is duplicated in singular and plural." \
-          "The singular wording will be ignored. You should keep one version of the key (singular or plural)"
-        )
-        data[key].values.each { |wording| wording.delete(:singular) }
-      end
-    end
-  end
-end

data/lib/ad_localize/platform/android_formatter.rb

@@ -1,70 +0,0 @@
-module AdLocalize::Platform
-  class AndroidFormatter < PlatformFormatter
-    def platform
-      :android
-    end
-
-    def export(locale, data, export_extension = nil, substitution_format = nil)
-      locale = locale.to_sym
-      export_dir_suffix = (locale == default_locale) ? "" : "-#{locale.downcase}"
-      create_locale_dir(export_dir_suffix)
-
-      xml_doc = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
-        xml.resources {
-          data.each do |key, wording|
-            singular_wording = wording.dig(locale, AdLocalize::Constant::SINGULAR_KEY_SYMBOL)
-            unless singular_wording.blank?
-              comment = wording.dig(locale, AdLocalize::Constant::COMMENT_KEY_SYMBOL)
-              add_singular_wording_to_xml(key, singular_wording, xml, comment: comment)
-            end
-
-            plural_wording = wording.dig(locale, AdLocalize::Constant::PLURAL_KEY_SYMBOL)
-            add_plural_wording_to_xml(key, plural_wording, xml) unless plural_wording.blank?
-          end
-        }
-      end
-
-      export_dir(export_dir_suffix).join(AdLocalize::Constant::ANDROID_EXPORT_FILENAME).open("w") do |file|
-        file.puts xml_doc.to_xml(indent: 4)
-      end
-      AdLocalize::LOGGER.log(:debug, :black, "Android [#{locale}] ---> DONE!")
-    end
-
-    private
-
-    def ios_converter(value)
-      processedValue = value.gsub(/(?<!\\)'/, "\\\\'") # match ' unless there is a \ before
-      processedValue = processedValue.gsub(/(?<!\\)\"/, "\\\"") # match " unless there is a \ before
-      processedValue = processedValue.gsub(/(%(\d+\$)?@)/, '%\2s') # should match values like %1$s and %s
-      processedValue = processedValue.gsub(/(%((\d+\$)?(\d+)?)i)/, '%\2d') # should match values like %i, %3$i, %01i, %1$02i
-      processedValue = processedValue.gsub(/%(?!((\d+\$)?(s|(\d+)?d)))/, '%%') # negative lookahead: identifies when user really wants to display a %
-      processedValue = processedValue.gsub("\\U", "\\u")
-      "\"#{processedValue}\""
-    end
-
-    def add_singular_wording_to_xml(key, text, xml, comment: nil)
-      xml.comment(comment) unless comment.blank?
-      xml.string(name: key) {
-        add_wording_text_to_xml(text, xml)
-      }
-    end
-
-    def add_plural_wording_to_xml(key, plural_hash, xml)
-      xml.plurals(name: key) {
-        plural_hash.each do |plural_type, plural_text|
-          next if plural_text.blank?
-          xml.item(quantity: plural_type) {
-            add_wording_text_to_xml(plural_text, xml)
-          }
-        end
-      } unless plural_hash.values.all? &:empty?
-    end
-
-    def add_wording_text_to_xml(wording_text, xml)
-      raise 'Wording text should not be empty' if wording_text.blank?
-      xml.text(
-        ios_converter(wording_text)
-      )
-    end
-  end
-end

data/lib/ad_localize/platform/ios_formatter.rb

@@ -1,143 +0,0 @@
-module AdLocalize::Platform
-  class IosFormatter < PlatformFormatter
-    def platform
-      :ios
-    end
-
-    def export(locale, data, export_extension = nil, substitution_format = nil)
-      create_locale_dir(locale)
-      all_symbols = [
-        AdLocalize::Constant::PLURAL_KEY_SYMBOL,
-        AdLocalize::Constant::ADAPTIVE_KEY_SYMBOL,
-        AdLocalize::Constant::SINGULAR_KEY_SYMBOL,
-        AdLocalize::Constant::INFO_PLIST_KEY_SYMBOL
-      ]
-      all_symbols.each do |numeral_key|
-        numeral_data = data.select {|key, wording| wording.dig(locale.to_sym)&.key? numeral_key}
-        if numeral_data.empty?
-          AdLocalize::LOGGER.log(:info, :green, "[#{locale.upcase}] no #{numeral_key.to_s} keys were found to generate the file")
-        else
-          send("write_#{numeral_key}", locale, numeral_data)
-        end
-      end
-    end
-
-    protected
-
-    def write_singular(locale, singulars)
-      write_localizable(
-        locale: locale,
-        singulars: singulars,
-        wording_type: AdLocalize::Constant::SINGULAR_KEY_SYMBOL,
-        filename: AdLocalize::Constant::IOS_SINGULAR_EXPORT_FILENAME
-      )
-    end
-
-    def write_info_plist(locale, singulars)
-      write_localizable(
-        locale: locale,
-        singulars: singulars,
-        wording_type: AdLocalize::Constant::INFO_PLIST_KEY_SYMBOL,
-        filename: AdLocalize::Constant::IOS_INFO_PLIST_EXPORT_FILENAME
-      )
-    end
-
-    def write_plural(locale, plurals)
-      locale = locale.to_sym
-
-      append_to_localizable_plist(locale) do |xml|
-        plurals.each do |wording_key, translations|
-          xml.key wording_key
-          xml.dict {
-            xml.key "NSStringLocalizedFormatKey"
-            xml.string "%\#@key@"
-            xml.key "key"
-            xml.dict {
-              xml.key "NSStringFormatSpecTypeKey"
-              xml.string "NSStringPluralRuleType"
-              xml.key "NSStringFormatValueTypeKey"
-              xml.string "d"
-              translations[locale][AdLocalize::Constant::PLURAL_KEY_SYMBOL].each do |wording_type, wording_value|
-                xml.key wording_type
-                xml.string wording_value
-              end
-            }
-          }
-        end
-      end
-      AdLocalize::LOGGER.log(:debug, :green, "iOS plural [#{locale}] ---> DONE!")
-    end
-
-    def write_adaptive(locale, adaptives)
-      locale = locale.to_sym
-
-      append_to_localizable_plist(locale) do |xml|
-        adaptives.each do |wording_key, translations|
-          xml.key wording_key
-          xml.dict {
-            xml.key "NSStringVariableWidthRuleType"
-            xml.dict {
-              translations[locale][AdLocalize::Constant::ADAPTIVE_KEY_SYMBOL].each do |wording_type, wording_value|
-                xml.key wording_type
-                xml.string wording_value
-              end
-            }
-          }
-        end
-      end
-      AdLocalize::LOGGER.log(:debug, :black, "iOS adaptive [#{locale}] ---> DONE!")
-    end
-
-    private
-
-    def escape_quotes_if_needed(value)
-      value.gsub(/(?<!\\)\"/, "\\\"") # match " unless there is a \ before
-    end
-
-    def write_localizable(locale:, singulars:, wording_type:, filename:)
-      locale = locale.to_sym
-
-      singulars.each do |key, locales_wording|
-        value = locales_wording.dig(locale, wording_type)
-        value = escape_quotes_if_needed(value)
-        comment = locales_wording.dig(locale, AdLocalize::Constant::COMMENT_KEY_SYMBOL)
-        export_dir(locale).join(filename).open("a") do |file|
-          line = ""
-          if wording_type == AdLocalize::Constant::INFO_PLIST_KEY_SYMBOL
-            line = %(#{key} = "#{value}";)
-          else
-            line = %("#{key}" = "#{value}";)
-          end
-          line << " // #{comment}" unless comment.nil?
-          line << "\n"
-          file.puts line
-        end
-      end
-      AdLocalize::LOGGER.log(:debug, :green, "iOS #{wording_type} [#{locale}] ---> DONE!")
-    end
-
-    def append_to_localizable_plist(locale)
-      filename = export_dir(locale).join(AdLocalize::Constant::IOS_PLURAL_EXPORT_FILENAME)
-      xml_doc = nil
-      if File.exist?(filename)
-        xml_content = Nokogiri::XML(open(filename)) do |config|
-          config.default_xml.noblanks # minimify xml
-        end
-        xml_doc = Nokogiri::XML::Builder.with(xml_content.css('plist>dict').first) do |xml|
-          yield(xml)
-        end
-      else
-        xml_doc = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
-          xml.plist {
-            xml.dict {
-              yield(xml)
-            }
-          }
-        end
-      end
-      filename.open("w") do |file|
-        file.puts xml_doc.to_xml(indent: 4)
-      end
-    end
-  end
-end

data/lib/ad_localize/platform/json_formatter.rb

@@ -1,17 +0,0 @@
-module AdLocalize::Platform
-  class JsonFormatter < PlatformFormatter
-    def platform
-      :json
-    end
-
-    def export(locale, data, export_extension = "json", substitution_format = "react")
-      locale = locale.to_sym
-      json_data = build_platform_data_splitting_on_dots(locale, data)
-      platform_dir.join("#{locale.to_s}.#{export_extension}").open("w") do |file|
-        file.puts json_data.to_json
-      end
-
-      AdLocalize::LOGGER.log(:debug, :green, "JSON [#{locale}] ---> DONE!")
-    end
-  end
-end

data/lib/ad_localize/platform/platform_formatter.rb

@@ -1,109 +0,0 @@
-module AdLocalize::Platform
-  class PlatformFormatter
-    PLURAL_KEY_SYMBOL = :plural
-    SINGULAR_KEY_SYMBOL = :singular
-    OPTIONS = {output_path: ".."}
-
-    attr_accessor :platform_dir
-    attr_reader :default_locale, :output_path, :add_intermediate_platform_dir
-
-    def initialize(default_locale, output_path, add_intermediate_platform_dir)
-      @default_locale = default_locale.to_sym
-      @output_path = output_path # Must be set before platform_dir
-      @platform_dir = add_intermediate_platform_dir ? export_base_directory.join(platform.to_s) : export_base_directory
-      @add_intermediate_platform_dir = add_intermediate_platform_dir
-      create_platform_dir
-    end
-
-    def platform
-      raise 'Please override me!'
-    end
-
-    def export(locale, data, export_extension, substitution_format)
-      locale = locale.to_sym
-      formatted_data = data.each_with_object({}) do |(key, wording), hash_acc|
-        hash_acc[locale.to_s] = {} unless hash_acc.key? locale.to_s
-        if wording.dig(locale)&.key? :singular
-          value = ios_converter(wording.dig(locale, :singular))
-          hash_acc[locale.to_s][key.to_s] = value
-        end
-        if wording.dig(locale)&.key? :plural
-          hash_acc[locale.to_s][key.to_s] = {}
-          wording.dig(locale, :plural).each do |plural_type, plural_text|
-            value = ios_converter(plural_text)
-            hash_acc[locale.to_s][key.to_s][plural_type.to_s] = value
-          end
-        end
-      end
-
-      platform_dir.join("#{locale.to_s}.#{export_extension}").open("w") do |file|
-        yield(formatted_data, file)
-      end
-
-      AdLocalize::LOGGER.log(:debug, :green, "#{platform.to_s.upcase} [#{locale}] ---> DONE!")
-    end
-
-    protected
-    def export_base_directory
-      if output_path
-        Pathname.new(output_path)
-      else
-        Pathname::pwd.join(AdLocalize::Constant::EXPORT_FOLDER)
-      end
-    end
-
-    def create_platform_dir
-      if platform_dir.directory? && add_intermediate_platform_dir
-        FileUtils.rm_rf("#{platform_dir}/.", secure: true)
-      else
-        platform_dir.mkpath
-      end
-    end
-
-    def export_dir(locale)
-      platform_dir + AdLocalize::Constant::CONFIG.dig(:platforms, :export_directory_names, platform.to_sym) % { locale: locale.downcase }
-    end
-
-    def create_locale_dir(locale)
-      raise 'Locale needed' unless locale
-
-      if export_dir(locale).directory?
-        FileUtils.rm_rf("#{export_dir(locale)}/.", secure: true)
-      else
-        export_dir(locale).mkdir
-      end
-    end
-
-    def build_platform_data_splitting_on_dots(locale, data)
-      data.each_with_object({}) do |(key, wording), hash_acc|
-        hash_acc[locale.to_s] = {} unless hash_acc.key? locale.to_s
-        keys = key.to_s.split('.')
-        hash = hash_acc[locale.to_s]
-        keys.each_with_index do |inner_key, index|
-          if index === keys.count - 1
-            fill_hash(wording, locale, hash, inner_key)
-          else
-            if hash[inner_key].nil?
-              hash[inner_key] = {}
-            end
-            hash = hash[inner_key]
-          end
-        end
-      end
-    end
-
-    def fill_hash(wording, locale, hash, key)
-      if wording.dig(locale)&.key? :singular
-        value = wording.dig(locale, :singular)
-        hash[key.to_s] = value
-      end
-      if wording.dig(locale)&.key? :plural
-        hash[key.to_s] = {}
-        wording.dig(locale, :plural).each do |plural_type, plural_text|
-          value = plural_text
-          hash[key.to_s][plural_type.to_s] = value
-        end
-      end
-    end
-  end
-end