ad_localize 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ae0a65677bc70e3175aae752514334aac36642bfb2a2dc2ce8e750f70bbf1d2
+  data.tar.gz: 30fb7aa05e9b7b6d27f608ec8d9c712f71be21be91560f082cb13f935167e258
+SHA512:
+  metadata.gz: f9e675d6438e1883632aa685e74166021fbe71e75ae1de4b4fda6d93b5c3705b177e0b19dc7399737261d97499c6521c5f746228e021df5401f97ef3fa57ccd6
+  data.tar.gz: 86b8d0efe4d91fe6eebb6849a76e1bb090c797de13ce3d430fb8a49efa7c93986626a1bb31bfccc639b19006ab7f6edae8c60e339f36b3aeb5d8734fc3e5b024

data/bin/ad_localize

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+require 'ad_localize'
+AdLocalize.run

data/lib/ad_localize.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'active_support'
+require 'active_support/core_ext'
+require 'byebug'
+require 'fileutils'
+require 'pathname'
+require 'yaml'
+require 'logger'
+require 'colorize'
+require 'csv'
+require 'active_support'
+require 'open-uri'
+require 'optparse'
+require 'json'
+require 'nokogiri'
+
+require 'ad_localize/ad_logger'
+require 'ad_localize/constant'
+require 'ad_localize/csv_file_manager'
+require 'ad_localize/csv_parser'
+require 'ad_localize/option_handler'
+require 'ad_localize/runner'
+require 'ad_localize/platform/platform_formatter'
+require 'ad_localize/platform/android_formatter'
+require 'ad_localize/platform/ios_formatter'
+require 'ad_localize/platform/json_formatter'
+require 'ad_localize/platform/yml_formatter'
+
+module AdLocalize
+  LOGGER = AdLogger.new
+
+  def self.run
+    Runner.new.run
+  end
+end

data/lib/ad_localize/ad_logger.rb

@@ -0,0 +1,33 @@
+module AdLocalize
+  class AdLogger
+    SEVERITY = { debug: Logger::DEBUG , info: Logger::INFO, warn: Logger::WARN, error: Logger::ERROR, fatal: Logger::FATAL, unknown: Logger::UNKNOWN }
+    AUTHORIZED_COLORS  = [:black, :yellow, :red, :blue, :green]
+
+    def initialize
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+    end
+
+    def log(level, color, text)
+      exit unless text and level and color
+
+      level, color = [level, color].map(&:to_sym)
+      raise "Color not supported" unless AUTHORIZED_COLORS.include? color
+      raise "Invalid severity" unless SEVERITY.dig(level)
+
+      @logger.add(SEVERITY.dig(level), text.send(color))
+    end
+
+    def debug!
+      @logger.level = Logger::DEBUG
+    end
+
+    def debug?
+      @logger.debug?
+    end
+
+    def close
+      @logger.close
+    end
+  end
+end

data/lib/ad_localize/constant.rb

@@ -0,0 +1,22 @@
+module AdLocalize
+  module Constant
+    SUPPORTED_PLATFORMS = %w(ios android yml json)
+    PLURAL_KEY_SYMBOL = :plural
+    SINGULAR_KEY_SYMBOL = :singular
+    COMMENT_KEY_SYMBOL = :comment
+    COMMENT_KEY_COLUMN_IDENTIFIER = "comment"
+    DEFAULT_CONFIG = {
+      platforms: {
+        export_directory_names: {
+          ios: "%{locale}.lproj",
+          android: "values%{locale}"
+        }
+      }
+    }
+    CONFIG = YAML.load_file(Pathname::pwd + 'config.yml').deep_symbolize_keys rescue DEFAULT_CONFIG
+    EXPORT_FOLDER = 'exports'
+    IOS_SINGULAR_EXPORT_FILENAME = "Localizable.strings"
+    IOS_PLURAL_EXPORT_FILENAME = "Localizable.stringsdict"
+    ANDROID_EXPORT_FILENAME = "strings.xml"
+  end
+end

data/lib/ad_localize/csv_file_manager.rb

@@ -0,0 +1,46 @@
+module AdLocalize
+  class CsvFileManager
+    CSV_CONTENT_TYPES = %w(text/csv text/plain)
+
+    class << self
+      def csv?(file)
+        !file.nil? && CSV_CONTENT_TYPES.include?(`file --brief --mime-type '#{file}'`.strip)
+      end
+
+      # Returns the downloaded file name (it is located in the current directory)
+      def download_from_drive(key)
+        LOGGER.log(:info, :black, "Downloading file from google drive...")
+        download_string_path = "./#{key}.csv"
+        begin
+          File.open(download_string_path, "wb") do |saved_file|
+            # the following "open" is provided by open-uri
+            open(drive_download_url(key), "rb") do |read_file|
+              saved_file.write(read_file.read)
+            end
+            File.basename saved_file
+          end
+        rescue => e
+          delete_drive_file(download_string_path)
+          LOGGER.log(:error, :red, e.message)
+          exit
+        end
+      end
+
+      def select_csvs(files)
+        files.select do |file|
+          LOGGER.log(:error, :red, "#{file} is not a csv. It will be ignored") unless self.csv?(file)
+          self.csv?(file)
+        end
+      end
+
+      def delete_drive_file(file)
+        Pathname.new(file).delete unless file.nil?
+      end
+
+      private
+      def drive_download_url(key)
+        "https://docs.google.com/spreadsheets/d/#{key}/export?format=csv&id=#{key}"
+      end
+    end
+  end
+end

data/lib/ad_localize/csv_parser.rb

@@ -0,0 +1,127 @@
+module AdLocalize
+  class CsvParser
+    CSV_WORDING_KEYS_COLUMN = "key"
+    PLURAL_KEY_REGEXP = /\#\#\{(\w+)\}/
+
+    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?
+          next
+        elsif validity_status == -1
+          exit
+        else
+          find_locales(row) if locales.empty?
+          row_data = parse_row(row)
+          data.deep_merge!(row_data) unless row_data.nil?
+        end
+      end
+      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?
+        LOGGER.log(:error, :red, "Missing key in line #{$.}") unless row.fields.all?(&:nil?)
+        valid_row = 0
+      elsif not row.headers.include?(CSV_WORDING_KEYS_COLUMN)
+        LOGGER.log(:error, :red, "[CSV FORMAT] #{file_name} is not a valid file")
+        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, :black, "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)})") }
+        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)
+      plural_prefix = key.match(PLURAL_KEY_REGEXP)
+      plural_identifier = nil
+      invalid_plural = false
+
+      if plural_prefix.nil?
+        numeral_key = Constant::SINGULAR_KEY_SYMBOL
+      else
+        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?
+      end
+
+      (key.nil? or invalid_plural) ? nil : { key: key.to_sym, numeral_key: numeral_key, plural_identifier: plural_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, :black, 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
+  end
+end

data/lib/ad_localize/option_handler.rb

@@ -0,0 +1,57 @@
+module AdLocalize
+  class OptionHandler
+    GOOGLE_DRIVE_DOCUMENT_ID = { length: 32, regexp: /\A[\w-]+\Z/ }
+
+    class << self
+      def parse
+        args = { debug: false, only: nil}
+
+        opt_parser = OptionParser.new do |opts|
+          opts.banner = "Usage: ruby bin/export [options] file(s)"
+
+
+          opts.on("-h", "--help", "Prints help") do
+            puts opts
+            exit
+          end
+          opts.on("-d", "--debug", "Run in debug mode") do
+            args[:debug] = true
+            LOGGER.debug!
+          end
+          opts.on("-k", "--drive-key #{GOOGLE_DRIVE_DOCUMENT_ID.dig(:length)}_characters", String, "Use google drive spreadsheets") do |key|
+            is_valid_drive_key = !!(key =~ GOOGLE_DRIVE_DOCUMENT_ID.dig(:regexp)) && (key.size >= GOOGLE_DRIVE_DOCUMENT_ID.dig(:length))
+            args[:drive_key] = is_valid_drive_key ? key : nil
+          end
+          opts.on("-o", "--only platform1,platform2", Array, "Only generate localisation files for the specified platforms. Supported platforms : #{Constant::SUPPORTED_PLATFORMS.join(', ')}") do |platforms|
+            args[:only] = filter_option_args("-o", platforms) { |platform| !!Constant::SUPPORTED_PLATFORMS.index(platform) }
+          end
+          opts.on("-t", "--target-dir PATH", String, "Path to the target directory") do |output_path|
+            pn = Pathname.new(output_path)
+            if pn.directory? and pn.readable? and pn.writable?
+              args[:output_path] = output_path
+            else
+              raise ArgumentError.new("Invalid target directory. Check the permissions")
+            end
+          end
+        end
+
+        begin
+          opt_parser.parse!
+        rescue OptionParser::MissingArgument => e
+          LOGGER.log(:error, :red, "Missing argument for option #{e.args.join(',')}")
+        rescue ArgumentError => e
+          LOGGER.log(:error, :red, e.message)
+        end
+        args
+      end
+
+      private
+      def filter_option_args(option, args)
+        result = args.select { |arg| yield(arg) }
+        invalid_args = args - result
+        LOGGER.log(:debug, :red, "Invalid arg(s) for option #{option}: #{invalid_args.join(', ')}") unless invalid_args.empty?
+        result
+      end
+    end
+  end
+end

data/lib/ad_localize/platform/android_formatter.rb

@@ -0,0 +1,68 @@
+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)
+            add_singular_wording_to_xml(key, singular_wording, xml) unless singular_wording.blank?
+
+            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(/</, "&lt;")
+      processedValue = processedValue.gsub(/>/, "&gt;")
+      processedValue = processedValue.gsub(/(?<!\\)'/, "\\\\'")
+      processedValue = processedValue.gsub(/(?<!\\)\"/, "\\\"")
+      processedValue = processedValue.gsub(/&(?!(?:amp|lt|gt|quot|apos);)/, '&amp;')
+      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)
+      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
+      }
+    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

@@ -0,0 +1,69 @@
+module AdLocalize::Platform
+  class IosFormatter < PlatformFormatter
+    def platform
+      :ios
+    end
+
+    def export(locale, data, export_extension = nil, substitution_format = nil)
+      create_locale_dir(locale)
+      [AdLocalize::Constant::PLURAL_KEY_SYMBOL, AdLocalize::Constant::SINGULAR_KEY_SYMBOL].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, :black, "[#{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)
+      locale = locale.to_sym
+
+      singulars.each do |key, locales_wording|
+        value = locales_wording.dig(locale, AdLocalize::Constant::SINGULAR_KEY_SYMBOL)
+        comment = locales_wording.dig(locale, AdLocalize::Constant::COMMENT_KEY_SYMBOL)
+        export_dir(locale).join(AdLocalize::Constant::IOS_SINGULAR_EXPORT_FILENAME).open("a") do |file|
+          line =  "\"#{key}\" = \"#{value}\";"
+          line << " // #{comment}" unless comment.nil?
+          line << "\n"
+          file.puts line
+        end
+      end
+      AdLocalize::LOGGER.log(:debug, :black, "iOS singular [#{locale}] ---> DONE!")
+    end
+
+    def write_plural(locale, plurals)
+      locale = locale.to_sym
+
+      xml_doc = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+        xml.plist {
+          xml.dict {
+            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
+      export_dir(locale).join(AdLocalize::Constant::IOS_PLURAL_EXPORT_FILENAME).open("w") do |file|
+        file.puts xml_doc.to_xml(indent: 4)
+      end
+      AdLocalize::LOGGER.log(:debug, :black, "iOS plural [#{locale}] ---> DONE!")
+    end
+  end
+end

data/lib/ad_localize/platform/json_formatter.rb

@@ -0,0 +1,18 @@
+module AdLocalize::Platform
+  class JsonFormatter < PlatformFormatter
+    def platform
+      :json
+    end
+
+    def export(locale, data, export_extension = "json", substitution_format = "angular")
+      super(locale, data, export_extension, substitution_format) do |json_data, file|
+        file.puts json_data.to_json
+      end
+    end
+
+    protected
+    def ios_converter(value)
+      value.gsub(/(%(?!)?(\d+\$)?[@isd])/, "VARIABLE_TO_SET")
+    end
+  end
+end

data/lib/ad_localize/platform/platform_formatter.rb

@@ -0,0 +1,76 @@
+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
+
+    def initialize(default_locale, output_path)
+      @default_locale = default_locale.to_sym
+      @output_path = output_path # Must be set before platform_dir
+      @platform_dir = export_base_directory.join(platform.to_s)
+      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] = {} unless hash_acc[locale.to_s].key? 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, :black, "#{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?
+        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
+  end
+end

data/lib/ad_localize/platform/yml_formatter.rb

@@ -0,0 +1,18 @@
+module AdLocalize::Platform
+  class YmlFormatter < PlatformFormatter
+    def platform
+      :yml
+    end
+
+    def export(locale, data, export_extension = "yml", substitution_format = "yml")
+      super(locale, data, export_extension, substitution_format) do |yml_data, file|
+        file.puts yml_data.to_yaml
+      end
+    end
+
+    protected
+    def ios_converter(value)
+      value.gsub(/(%(?!)?(\d+\$)?[@isd])/, "VARIABLE_TO_SET")
+    end
+  end
+end

data/lib/ad_localize/runner.rb

@@ -0,0 +1,45 @@
+module AdLocalize
+  class Runner
+    attr_accessor :options
+
+    def initialize
+      @options = OptionHandler.parse
+    end
+
+    def run(args = ARGV)
+      LOGGER.log(:info, :black, "OPTIONS : #{options}")
+      input_files = (args + [options.dig(:drive_key)]).compact # drive_key can be nil
+      if input_files.length.zero?
+        LOGGER.log(:error, :red, "No CSV to parse. Use option -h to see how to use this script")
+      else
+        file_to_parse = args.first
+        LOGGER.log(:warn, :yellow, "Only one CSV can be treated - the priority goes to #{file_to_parse}") if input_files.length > 1
+        if args.empty?
+          options[:drive_file] = CsvFileManager.download_from_drive(options.dig(:drive_key))
+          file_to_parse = options.dig(:drive_file)
+        end
+        CsvFileManager.csv?(file_to_parse) ? export(file_to_parse) : LOGGER.log(:error, :red, "#{file_to_parse} is not a csv")
+        CsvFileManager.delete_drive_file(options[:drive_file]) if options[:drive_file]
+      end
+    end
+
+    private
+    def export(file)
+      LOGGER.log(:info, :black, "********* PARSING #{file} *********")
+      LOGGER.log(:info, :black, "Extracting data from file...")
+      parser = CsvParser.new
+      data = parser.extract_data(file)
+      if data.empty?
+        LOGGER.log(:error, :red, "No data were found in the file - cannot start the file generation process")
+      else
+        export_platforms = options.dig(:only) || Constant::SUPPORTED_PLATFORMS
+        export_platforms.each do |platform|
+          platform_formatter = "AdLocalize::Platform::#{platform.to_s.camelize}Formatter".constantize.new(parser.locales.first, options.dig(:output_path))
+          parser.locales.each do |locale|
+            platform_formatter.export(locale, data)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: ad_localize
+version: !ruby/object:Gem::Version
+  version: 2.1.0
+platform: ruby
+authors:
+- Edouard Siegel
+- Patrick Nollet
+- Adrien Couque
+- Tarek Belkahia
+- Hugo Hache
+- Vincent Brison
+- Joanna Vigné
+- Nicolas Braun
+- Corentin Huard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.5
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: " Convert a wording file in localization files. Supported export formats
+  are : iOS, Android,\n   JSON and YAML "
+email:
+- joanna.vigne@fabernovel.com
+- hugo.hache@fabernovel.com
+- edouard.siegel@fabernovel.com
+executables:
+- ad_localize
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ad_localize
+- lib/ad_localize.rb
+- lib/ad_localize/ad_logger.rb
+- lib/ad_localize/constant.rb
+- lib/ad_localize/csv_file_manager.rb
+- lib/ad_localize/csv_parser.rb
+- lib/ad_localize/option_handler.rb
+- lib/ad_localize/platform/android_formatter.rb
+- lib/ad_localize/platform/ios_formatter.rb
+- lib/ad_localize/platform/json_formatter.rb
+- lib/ad_localize/platform/platform_formatter.rb
+- lib/ad_localize/platform/yml_formatter.rb
+- lib/ad_localize/runner.rb
+homepage: https://technologies.fabernovel.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: AdLocalize
+test_files: []