applocale 0.1.0

data/lib/applocale/Core/google_helper.rb

@@ -0,0 +1,69 @@
+require 'google/apis/drive_v3'
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require 'google/apis/sheets_v4'
+require 'fileutils'
+require File.expand_path('../../Util/file_util.rb', __FILE__)
+require File.expand_path('../../Util/color_util.rb', __FILE__)
+require File.expand_path('../../Util/error_util.rb', __FILE__)
+
+module Applocale
+
+  class GoogleHelper
+    OOB_URI = 'urn:ietf:wg:oauth:2.0:oob'
+    APPLICATION_NAME = 'AppLocale'
+    CLIENT_SECRETS_PATH = 'client_secret.json'
+    CREDENTIALS_PATH = File.join(Dir.home, '.applan_credentials',
+                                 "drive-ruby-applocale.yaml")
+    SCOPE = [Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY, Google::Apis::DriveV3::AUTH_DRIVE, Google::Apis::DriveV3::AUTH_DRIVE_FILE]
+
+    def self.isGoogleLink(link)
+      if !link.nil? && link.length > 0
+        if link.match(/https:\/\/docs.google.com\/spreadsheets\/d\/([^\/]*)/i)
+          if $1.length > 0
+            return $1
+          end
+        end
+      end
+    end
+
+    def self.downloadSpreadSheet(spreadSheetId, filename)
+      puts "Start download from google, fileId: #{spreadSheetId} ...".green
+      service = Google::Apis::DriveV3::DriveService.new
+      service.client_options.application_name = APPLICATION_NAME
+      service.authorization = self.authorize
+      content = service.export_file(spreadSheetId,
+                                    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                                    download_dest: filename)
+      if File.exist? filename
+        puts "Download from google finished".green
+      else
+        ErrorUtil::DownloadXlsxError.new("Cannot download from google").raise
+      end
+    end
+
+    private
+    def self.authorize
+
+      FileUtils.mkdir_p(File.dirname(CREDENTIALS_PATH))
+      client_id = Google::Auth::ClientId.from_file(File.expand_path(CLIENT_SECRETS_PATH, File.dirname(__FILE__)))
+      token_store = Google::Auth::Stores::FileTokenStore.new(file: CREDENTIALS_PATH)
+      authorizer = Google::Auth::UserAuthorizer.new(
+          client_id, SCOPE, token_store)
+      user_id = 'default'
+      credentials = authorizer.get_credentials(user_id)
+      if credentials.nil?
+        url = authorizer.get_authorization_url(
+            base_url: OOB_URI)
+        puts "!!! Open the following URL in the browser and enter the ".red +
+                 "resulting code after authorization:".red
+        puts url.blue.on_white
+        code = STDIN.gets.chomp
+        credentials = authorizer.get_and_store_credentials_from_code(
+            user_id: user_id, code: code, base_url: OOB_URI)
+      end
+      credentials
+    end
+
+  end
+end

data/lib/applocale/Core/init.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../setting.rb', __FILE__)
+require File.expand_path('../google_helper.rb', __FILE__)
+require File.expand_path('../parse_xlsx', __FILE__)
+require File.expand_path('../convert_to_str_file', __FILE__)
+
+module Applocale
+  def self.start(is_localupdate, setting)
+    if !is_localupdate
+      google_file_id = GoogleHelper.isGoogleLink(setting.link)
+      if !google_file_id.nil?
+        GoogleHelper.downloadSpreadSheet(google_file_id,setting.xlsxpath)
+      end
+    end
+
+    parseXlsx = ParseXLSX.new()
+    ConvertToStrFile.convert(parseXlsx.result)
+  end
+
+end

data/lib/applocale/Core/parse_xlsx.rb

@@ -0,0 +1,166 @@
+require File.expand_path('../setting.rb', __FILE__)
+require File.expand_path('../parse_xlsx_module.rb', __FILE__)
+require File.expand_path('../../Util/error_util.rb', __FILE__)
+require File.expand_path('../../Util/color_util.rb', __FILE__)
+require File.expand_path('../../Util/regex_util.rb', __FILE__)
+
+require 'rubyXL'
+
+
+module Applocale
+  class ParseXLSX
+
+    @xlsx = nil
+    @sheetcontent_list = nil
+    @allError = nil
+    @setting = Setting
+
+    def initialize()
+      @setting = Setting
+      puts "Start to Parse XLSX: \"#{@setting.xlsxpath}\" ...".green
+      # @xlsx = Roo::Spreadsheet.open(@@setting.xlsxpath)
+      @sheetcontent_list = Array.new
+      @allKeyDict = {}
+      @allError = Array.new
+
+      self.parse()
+    end
+
+    def result
+      return @sheetcontent_list
+    end
+
+    def parse()
+
+      workbook = RubyXL::Parser.parse(@setting.xlsxpath)
+      workbook.worksheets.each do |worksheet|
+        sheetName = worksheet.sheet_name
+        sheetcontent = ParseXLSXModule::SheetContent.new(sheetName)
+
+        rowno = -1
+        worksheet.each {|row|
+          rowno += 1
+          # colno = 0
+          next if row.nil?
+          cells = row && row.cells
+          if sheetcontent.header_rowno.nil?
+            headerinfo = findHeader(cells)
+            if !headerinfo.nil?
+              sheetcontent.header_rowno = rowno
+              sheetcontent.keyStrWithColNo = headerinfo[:keystr_colno]
+              sheetcontent.langWithColNo_list = headerinfo[:lang_colno]
+            end
+          else
+            begin
+              rowcontent = parseRow(sheetName, rowno, worksheet.sheet_data[rowno], sheetcontent.keyStrWithColNo, sheetcontent.langWithColNo_list)
+              if !rowcontent.nil?
+                prev_rowcontent = @allKeyDict[rowcontent.key_str.downcase]
+                if prev_rowcontent.nil?
+                  @allKeyDict[rowcontent.key_str.downcase] = rowcontent
+                  sheetcontent.rowinfo_list.push(rowcontent)
+                else
+                  error = ErrorUtil::ParseXlsxError::ErrorDuplicateKey.new(rowcontent, "duplicate with sheet '#{prev_rowcontent.sheetname}' row '#{prev_rowcontent.rowno}'")
+                  @allError.push(error)
+                end
+              end
+            rescue ErrorUtil::ParseXlsxError::ParseError => e
+              @allError.push(e)
+
+            end
+          end
+        }
+        if sheetcontent.header_rowno.nil?
+          ErrorUtil::ParseXlsxError::HeadeNotFoundError.new("Header not found in sheet: #{sheetName}").to_warn
+        end
+        @sheetcontent_list.push(sheetcontent)
+      end
+      if @allError.length > 0
+        ErrorUtil::ParseXlsxError::ParseError.raiseArr(@allError)
+      end
+
+    end
+
+    def parseRow(sheetname, rowno, cells, keyStrWithColNo, langWithColNo_list)
+      begin
+        cell = cells[keyStrWithColNo.colno]
+        val = cell && cell.value
+        keystr = toValueKey(val)
+      rescue ErrorUtil::ParseXlsxError::ErrorInValidKey => e
+        e.rowinfo.sheetname = sheetname
+        e.rowinfo.rowno = rowno
+        raise e
+      end
+
+      if !keystr.nil?
+        rowinfo = ParseXLSXModule::RowInfo.new(sheetname, rowno, keystr)
+        for k in 0..langWithColNo_list.length-1
+          langWithColNo = langWithColNo_list[k]
+          cell = cells[langWithColNo.colno]
+          val = cell && cell.value
+          cell_value = val.to_s
+          lang_name = langWithColNo.lang
+          rowinfo.content_dict[lang_name] = convertContect(cell_value)
+        end
+        return rowinfo
+      end
+      return nil
+    end
+
+    def toValueKey(value)
+      if !value.nil? && value != ""
+        new_value = value.to_s
+        if ValidKey.isValidKey(@setting.platform, new_value)
+          return new_value
+        else
+          rowinfo = ParseXLSXModule::RowInfo.new(nil, nil, value)
+          raise ErrorUtil::ParseXlsxError::ErrorInValidKey.new(rowinfo, "Invaild Key: #{value}")
+        end
+      end
+      return nil
+    end
+
+    def convertContect(cell_value)
+      if cell_value.nil?
+        return ""
+      else
+        return ContentUtil.addEscapedDoubleQuote(cell_value)
+      end
+    end
+
+    def findHeader(cells)
+      keyStrWithColNo = nil
+      langWithColNo_list = Array.new()
+      k_header_lang_dict = []
+      colno = 0
+      cells.each{ |cell|
+        value = cell && cell.value
+        if !value.nil?
+          if value == @setting.keystr && keyStrWithColNo.nil?
+            keyStrWithColNo = ParseXLSXModule::KeyStrWithColNo.new(value, colno)
+          else
+            @setting.langlist.each do |lang, info|
+              if value == info[:xlsheader] && k_header_lang_dict.index(lang).nil?
+                langWithColNo_list.push(ParseXLSXModule::LangWithColNo.new(info[:xlsheader], lang, colno))
+                k_header_lang_dict.push(lang)
+              end
+            end
+          end
+        end
+        colno += 1
+      }
+
+      allPass = true
+      for i in 0..langWithColNo_list.length-1
+        if langWithColNo_list[i].nil?
+          allPass = false
+          break
+        end
+      end
+      if !keyStrWithColNo.nil? && langWithColNo_list.length == @setting.langlist.length
+        return {:keystr_colno => keyStrWithColNo, :lang_colno => langWithColNo_list}
+      end
+      return nil
+    end
+
+  end
+end

data/lib/applocale/Core/parse_xlsx_module.rb

@@ -0,0 +1,91 @@
+module Applocale
+
+  module ParseXLSXModule
+    class SheetContent
+      attr_accessor :sheetname, :header_rowno, :keyStrWithColNo, :langWithColNo_list, :rowinfo_list, :comment
+
+      def initialize(sheetname)
+        self.sheetname = sheetname
+        self.rowinfo_list = Array.new()
+        self.langWithColNo_list = Array.new()
+        self.comment = sheetname
+      end
+
+      def getRowInfoSortByKey()
+        return self.rowinfo_list.sort_by { |obj| obj.key_str.to_s }
+      end
+
+      def getRowInfoSortByRowNo()
+        return self.rowinfo_list.sort_by { |obj| obj.rowno.to_i }
+      end
+
+      def to_s
+        str_keyStrWithColNo = ""
+        if !keyStrWithColNo.nil?
+          str_keyStrWithColNo = "\n\t#{keyStrWithColNo.to_s}"
+        end
+        str_langWithColNo_list = ""
+        self.langWithColNo_list.each do |langWithColNo|
+          str_langWithColNo_list += "\n\t#{langWithColNo.to_s}"
+        end
+        str_contentlist = "\n"
+        self.getRowInfoSortByRowNo().each do |value|
+          str_contentlist += "\t #{value.to_s}\n"
+        end
+
+        "sheetname = #{sheetname}\n" +
+            "header_rowno = #{header_rowno}\n" +
+            "keyStrWithColNo = #{str_keyStrWithColNo}\n" +
+            "langWithColNo_list = #{str_langWithColNo_list}\n" +
+            "rowinfo_list = #{str_contentlist}"
+      end
+    end
+
+    class RowInfo
+
+      attr_accessor :sheetname, :rowno, :key_str, :content_dict
+
+      def initialize(sheetname = nil, rowno = nil, key_str = nil)
+        self.sheetname = sheetname
+        self.rowno = rowno
+        self.key_str = key_str
+        self.content_dict = {}
+      end
+
+      def to_s
+        "sheetname = #{sheetname}, rowno = #{rowno}, key_str = #{key_str}, content_dict = #{content_dict}"
+      end
+
+    end
+
+    class KeyStrWithColNo
+
+      attr_accessor :header_str, :colno
+
+      def initialize(header_str, colno)
+        self.header_str = header_str
+        self.colno = colno
+      end
+
+      def to_s
+        "{header_str => #{header_str}, colno => #{colno}}"
+      end
+
+    end
+
+    class LangWithColNo
+      attr_accessor :header_str, :lang, :colno
+
+      def initialize(header_str, lang, colno)
+        self.header_str = header_str
+        self.lang = lang
+        self.colno = colno
+      end
+
+      def to_s
+        "{header_str => #{header_str}, lang => #{lang}, colno => #{colno}}"
+      end
+    end
+
+  end
+end

data/lib/applocale/Core/setting.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../../Util/color_util.rb', __FILE__)
+
+module Applocale
+  class Setting
+    class <<self
+      attr_accessor :link, :platform, :keystr, :langlist, :xlsxpath
+    end
+
+    def self.printlog
+      puts " In Setting"
+      puts "  link = #{self.link}"
+      puts "  platform = #{self.platform}"
+      puts "  keystr = #{self.keystr}"
+      puts "  langlist = #{self.langlist}"
+      puts "  xlsxpath = #{self.xlsxpath}"
+    end
+  end
+end

data/lib/applocale/Util/color_util.rb

@@ -0,0 +1,28 @@
+require 'colorize'
+
+
+# class String
+#   def black;          "\e[30m#{self}\e[0m" end
+#   def red;            "\e[31m#{self}\e[0m" end
+#   def green;          "\e[32m#{self}\e[0m" end
+#   def brown;          "\e[33m#{self}\e[0m" end
+#   def blue;           "\e[34m#{self}\e[0m" end
+#   def magenta;        "\e[35m#{self}\e[0m" end
+#   def cyan;           "\e[36m#{self}\e[0m" end
+#   def gray;           "\e[37m#{self}\e[0m" end
+#
+#   def bg_black;       "\e[40m#{self}\e[0m" end
+#   def bg_red;         "\e[41m#{self}\e[0m" end
+#   def bg_green;       "\e[42m#{self}\e[0m" end
+#   def bg_brown;       "\e[43m#{self}\e[0m" end
+#   def bg_blue;        "\e[44m#{self}\e[0m" end
+#   def bg_magenta;     "\e[45m#{self}\e[0m" end
+#   def bg_cyan;        "\e[46m#{self}\e[0m" end
+#   def bg_gray;        "\e[47m#{self}\e[0m" end
+#
+#   def bold;           "\e[1m#{self}\e[22m" end
+#   def italic;         "\e[3m#{self}\e[23m" end
+#   def underline;      "\e[4m#{self}\e[24m" end
+#   def blink;          "\e[5m#{self}\e[25m" end
+#   def reverse_color;  "\e[7m#{self}\e[27m" end
+# end

data/lib/applocale/Util/config_util.rb

@@ -0,0 +1,169 @@
+require 'yaml'
+require File.expand_path('../file_util.rb', __FILE__)
+require File.expand_path('../error_util.rb', __FILE__)
+require File.expand_path('../platform.rb', __FILE__)
+require File.expand_path('../../Core/setting.rb', __FILE__)
+
+require 'pathname'
+
+module Applocale
+  class ConfigUtil
+    def self.createConfigFileIfNeed(platform)
+      pathstr = FileUtil.configFilePathStr
+      self.createConfigFile(platform, pathstr) unless File.exist?(pathstr)
+    end
+
+    def self.createConfigFile(platform, configfile_pathstr)
+      src_pathstr = File.expand_path("../../#{FileUtil.filename_config}", __FILE__)
+
+      File.open(src_pathstr, "r") do |form|
+        File.open(configfile_pathstr, "w") do |to|
+          form.each_line do |line|
+            newline = line.gsub("\#{platform}", "#{platform.to_s}")
+            newline = newline.gsub("\#{path_zh_TW}", FileUtil.defaultLocaleFileRelativePathStr(platform, Locale::ZH_TW))
+            newline = newline.gsub("\#{path_zh_CN}", FileUtil.defaultLocaleFileRelativePathStr(platform, Locale::ZH_CN))
+            newline = newline.gsub("\#{path_en_US}", FileUtil.defaultLocaleFileRelativePathStr(platform, Locale::EN_US))
+            newline = newline.gsub("\#{xlsxpath}", FileUtil.defaultXlsxRelativePathStr())
+            to.puts(newline)
+          end
+
+        end
+      end
+    end
+
+    def self.loadAndValidateForXlsxToStringFile(is_local_update)
+      config_yaml = self.load_config
+      self.validateForXlsxToStringFile(config_yaml, is_local_update)
+    end
+
+    def self.loadAndValidateForStringFileToXlsx()
+      config_yaml = self.load_config
+      self.validateForStringFileToXlsx(config_yaml)
+    end
+
+    # private
+    def self.load_config
+      configfile_path = FileUtil.configFilePathStr
+      unless File.exist?(configfile_path)
+        ErrorUtil::MissingConfigFileError.new("Missing ConfigFile").raise
+      end
+      config_yaml = YAML.load_file configfile_path
+      return config_yaml
+    end
+
+    def self.validateForXlsxToStringFile(config_yaml, is_local_update)
+      error_list = self.validateCommon(config_yaml)
+      if is_local_update
+        if !File.exist? Setting.xlsxpath
+          error = ErrorUtil::ConfigFileValidError.new("#{Setting.xlsxpath} do not exist")
+          error_list.push(error)
+        end
+      else
+        if Setting.link.nil?
+          error = ErrorUtil::ConfigFileValidError.new("[link] should not be empty")
+          error_list.push(error)
+        end
+      end
+      ErrorUtil::ConfigFileValidError.raiseArr(error_list)
+    end
+
+    def self.validateForStringFileToXlsx(config_yaml)
+      error_list = self.validateCommon(config_yaml)
+      Setting.langlist.each do |lang, langinfo|
+        if !File.exist? langinfo[:path]
+          error = ErrorUtil::ConfigFileValidError.new("#{langinfo[:path]} do not exist")
+          error_list.push(error)
+        end
+      end
+      ErrorUtil::ConfigFileValidError.raiseArr(error_list)
+    end
+
+    def self.validateCommon(config_yaml)
+      error_list = Array.new
+      link = config_yaml["link"].to_s
+      platform = config_yaml["platform"].to_s
+      keystr = config_yaml["keystr"].to_s
+      langlist = config_yaml["langlist"]
+      xlsxpath = config_yaml["xlsxpath"].to_s
+
+      newlink = nil
+      newplatform = nil
+      newkeystr = nil
+      newlanglist = Hash.new
+      newxlsxpath = nil
+
+      if !(link.nil? || link.length == 0)
+        if (link =~ /^https/).nil? && (link =~ /^http/).nil?
+          error = ErrorUtil::ConfigFileValidError.new("Invalid link for [link] : #{link}")
+          error_list.push(error)
+        else
+          newlink = link
+        end
+      end
+
+      if !(xlsxpath.nil? || xlsxpath.length == 0)
+        if !(Pathname.new xlsxpath).absolute?
+          newxlsxpath = File.expand_path(xlsxpath, File.dirname(FileUtil.configFilePathStr))
+        else
+          newxlsxpath = xlsxpath
+        end
+      else
+        error = ErrorUtil::ConfigFileValidError.new("[xlsxpath] should not be empty or missing")
+        error_list.push(error)
+      end
+
+      if platform.nil? || platform.length == 0
+        error = ErrorUtil::ConfigFileValidError.new("[platform] should not be empty")
+        error_list.push(error)
+      else
+        if Platform.init(platform).nil?
+          error = ErrorUtil::ConfigFileValidError.new("[platform] can only be 'ios' or 'android' ")
+          error_list.push(error)
+        else
+          newplatform = Platform.init(platform)
+        end
+      end
+
+      if keystr.nil? || keystr.length == 0
+        error = ErrorUtil::ConfigFileValidError.new("[keystr] should not be empty")
+        error_list.push(error)
+      else
+        newkeystr = keystr
+      end
+
+      if langlist.nil?
+        error = ErrorUtil::ConfigFileValidError.new("[langlist] should not be empty or missing")
+        error_list.push(error)
+      elsif !(langlist.is_a? Hash)
+        error = ErrorUtil::ConfigFileValidError.new("[langlist] wrong format")
+        error_list.push(error)
+      else
+        if langlist.length <= 0
+          error = ErrorUtil::ConfigFileValidError.new("[langlist] should not be empty ")
+          error_list.push(error)
+        end
+        langlist.each do |lang, arr|
+          if arr.length != 2
+            error = ErrorUtil::ConfigFileValidError.new("[langlist] wrong format")
+            error_list.push(error)
+          else
+            path = arr[1]
+            if !(Pathname.new path).absolute?
+              path = File.expand_path(path, File.dirname(FileUtil.configFilePathStr))
+            end
+            newlanglist[lang] = {:xlsheader => arr[0], :path => path}
+          end
+        end
+      end
+
+      Setting.link = newlink
+      Setting.platform = newplatform
+      Setting.keystr = newkeystr
+      Setting.langlist = newlanglist
+      Setting.xlsxpath = newxlsxpath
+
+      return error_list
+    end
+
+  end
+end