applocale 0.1.6 → 0.2.0

data/lib/applocale/Core/GoogleHepler/google_helper.rb

@@ -12,79 +12,88 @@ module Applocale
     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.is_googlelink(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
+    attr_accessor :download_link, :credential_path, :xlsx_path,:spreadsheet_id
+
+    def initialize(link, credential_path, xlsx_path)
+      self.download_link = link.to_s.strip
+      self.credential_path = credential_path.to_s.strip
+      self.xlsx_path = xlsx_path.to_s.strip
+      self.spreadsheet_id = GoogleHelper.get_spreadsheet_id(link)
+
+      if self.download_link.length <= 0
+        ErrorUtil::ConfigFileInValid.new('[link] is missing in config file ').raise
+      end
+      if self.credential_path.length <= 0
+        ErrorUtil::ConfigFileInValid.new('[credential_path] is missing in config file ').raise
+      end
+      if self.xlsx_path.length <= 0
+        ErrorUtil::ConfigFileInValid.new('[xlsx_path] is missing in config file ').raise
       end
     end
 
-    def self.reset_loginacc
-      if File.exist? CREDENTIALS_PATH
-        File.delete(CREDENTIALS_PATH)
+    private
+    def removeOldExcel
+      if File.exist? self.xlsx_path
+        FileUtils.rm(self.xlsx_path)
       end
-      puts "Account Reseted!"
     end
 
-    def self.download_spreadsheet(spreadsheet_Id, filename)
-      puts "Start download from google, fileId: #{spreadsheet_Id} ...".green
+    public
+    def download
+      removeOldExcel
       service = Google::Apis::DriveV3::DriveService.new
       service.client_options.application_name = APPLICATION_NAME
-      service.authorization = self.authorize
+      service.authorization = authorize
       begin
-        service.export_file(spreadsheet_Id,
-                                      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-                                      download_dest: filename)
-        if File.exist? filename
+        service.export_file(self.spreadsheet_id,
+                            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                            download_dest: self.xlsx_path)
+        if File.exist? self.xlsx_path
           puts 'Download from google finished'.green
         else
           ErrorUtil::DownloadFromGoogleFail.new.raise
         end
       rescue Google::Apis::AuthorizationError => e
-        self.failauth(spreadsheet_Id, filename)
+        failauth
       rescue Google::Apis::ClientError => e
-        self.failauth(spreadsheet_Id, filename)
+        failauth
       rescue Google::Apis::ServerError => e
-        self.failauth( spreadsheet_Id, filename)
+        failauth
       rescue
         ErrorUtil::DownloadFromGoogleFail.new.raise
       end
     end
 
-    def self.failauth(spreadsheet_Id, filename)
+    private
+    def failauth
       ErrorUtil::DownloadFromGoogleFail.new.to_warn
-      self.askfor_relogin(true, spreadsheet_Id, filename)
+      askfor_relogin(true)
     end
 
     private
-    def self.askfor_relogin(is_firsttime, spreadsheet_Id, filename)
+    def askfor_relogin(is_firsttime)
       unless is_firsttime
         puts "Invalid Command. Please input [Y/N]".red
       end
       puts "login again? [Y/N]".red
       code = STDIN.gets.chomp.downcase
       if code == 'y'
-        self.reset_loginacc
-        self.download_spreadsheet(spreadsheet_Id, filename)
+        reset_loginacc
+        self.download
       elsif code == 'n'
         exit(0)
       else
-        self.askfor_relogin(false, spreadsheet_Id, filename)
+        askfor_relogin(false)
       end
     end
 
-    def self.authorize
-
-      FileUtils.mkdir_p(File.dirname(CREDENTIALS_PATH))
+    private
+    def authorize
+      FileUtils.mkdir_p(File.dirname(self.credential_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)
+      token_store = Google::Auth::Stores::FileTokenStore.new(file: self.credential_path)
       authorizer = Google::Auth::UserAuthorizer.new(
           client_id, SCOPE, token_store)
       user_id = 'default'
@@ -102,5 +111,37 @@ module Applocale
       credentials
     end
 
+    private
+    def reset_loginacc
+      if File.exist? self.credential_path
+        File.delete(self.credential_path)
+      end
+      puts "Account Reseted!"
+    end
+
+    public
+    def self.is_googlelink(link)
+      if !link.nil? && link.length > 0
+        if link.match(/https:\/\/docs.google.com\/spreadsheets\/d\/([^\/]*)/i)
+          if $1.length > 0
+            return true
+          end
+        end
+      end
+      return false
+    end
+
+    public
+    def self.get_spreadsheet_id(link)
+      if !link.nil? && link.length > 0
+        if link.match(/https:\/\/docs.google.com\/spreadsheets\/d\/([^\/]*)/i)
+          if $1.strip.length > 0
+            return $1.strip
+          end
+        end
+      end
+      ErrorUtil::DownloadFromGoogleFail.new.raise
+    end
+
   end
 end

data/lib/applocale/Core/ParseXLSX/parse_xlsx.rb

@@ -5,19 +5,30 @@ require File.expand_path('../../../Util/regex_util.rb', __FILE__)
 
 require 'rubyXL'
 require 'colorize'
+module Applocale
+  class Injeust
+
+  end
+end
 
 module Applocale
   class ParseXLSX
 
-    @xlsx = nil
     @sheetcontent_list = nil
     @allkey_dict = {}
     @all_error = nil
-    @setting = Setting
 
-    def initialize
-      @setting = Setting
-      puts "Start to Parse XLSX: \"#{@setting.xlsxpath}\" ...".green
+    @platform
+    @xlsxpath
+    @langlist
+    @sheetobj_list
+
+    def initialize(platfrom, xlsxpath, langlist, sheetobj_list)
+      @platform = platfrom
+      @xlsxpath = xlsxpath
+      @langlist = langlist
+      @sheetobj_list = sheetobj_list
+      puts "Start to Parse XLSX: \"#{@xlsxpath}\" ...".green
       @sheetcontent_list = Array.new
       @allkey_dict = {}
       @all_error = Array.new
@@ -30,29 +41,47 @@ module Applocale
 
     def parse
       begin
-        workbook = RubyXL::Parser.parse(@setting.xlsxpath)
+        workbook = RubyXL::Parser.parse(@xlsxpath)
       rescue
-        ErrorUtil::CannotOpenXlsxFile.new(@setting.xlsxpath).raise
+        ErrorUtil::CannotOpenXlsxFile.new(@xlsxpath).raise
       end
+      sheetnamelist = Applocale::Config::Sheet.get_sheetlist(@sheetobj_list)
       workbook.worksheets.each do |worksheet|
         sheetname = worksheet.sheet_name
+        sheetinfoobj = Applocale::Config::Sheet.get_sheetobj_by_sheetname(@sheetobj_list, sheetname)
+        if sheetinfoobj.nil?
+          next
+        end
+        sheetnamelist.delete(sheetname)
+
         sheetcontent = ParseXLSXModule::SheetContent.new(sheetname)
-        rowno = -1
+        if sheetinfoobj.is_a? Applocale::Config::SheetInfoByRow
+          keycolno = Applocale::ParseXLSXModule::Helper.collabel_to_colno(sheetinfoobj.key_col)
+          sheetinfoobj.to_keyStrWithColNo(sheetcontent)
+        end
+
+        rowno = 0
         worksheet.each {|row|
           rowno += 1
           # colno = 0
-          next if row.nil?
-          cells = row && row.cells
           if sheetcontent.header_rowno.nil?
-            headerinfo = find_header(cells)
-            unless headerinfo.nil?
-              sheetcontent.header_rowno = rowno
-              sheetcontent.keyStr_with_colno = headerinfo[:keystr_colno]
-              sheetcontent.lang_with_colno_list = headerinfo[:lang_colno]
+            if sheetinfoobj.is_a? Applocale::Config::SheetInfoByHeader
+              next if row.nil?
+              cells = row && row.cells
+              headerinfo = find_header(sheetinfoobj, cells)
+              unless headerinfo.nil?
+                sheetcontent.header_rowno = rowno
+                sheetcontent.keyStr_with_colno = headerinfo[:keystr_colno]
+                sheetcontent.lang_with_colno_list = headerinfo[:lang_colno]
+              end
             end
+          elsif sheetcontent.header_rowno > rowno
+            next
           else
+            next if row.nil?
+            cells = row && row.cells
             begin
-              rowcontent = parse_row(sheetname, rowno, worksheet.sheet_data[rowno], sheetcontent.keyStr_with_colno, sheetcontent.lang_with_colno_list)
+              rowcontent = parse_row(sheetname, rowno, cells, sheetcontent.keyStr_with_colno, sheetcontent.lang_with_colno_list)
               unless rowcontent.nil?
                 prev_rowcontent = @allkey_dict[rowcontent.key_str.downcase]
                 if prev_rowcontent.nil?
@@ -82,7 +111,7 @@ module Applocale
 
     def parse_row(sheetname, rowno, cells, keystr_with_colno, lang_with_colno_list)
       begin
-        cell = cells[keystr_with_colno.colno]
+        cell = cells[keystr_with_colno.colno - 1 ]
         val = cell && cell.value
         keystr = to_value_key(val)
       rescue ErrorUtil::ParseXlsxError::InValidKey => e
@@ -93,9 +122,8 @@ module Applocale
 
       unless keystr.nil?
         rowinfo = ParseXLSXModule::RowInfo.new(sheetname, rowno, keystr)
-        (0..lang_with_colno_list.length-1).each do |k|
-          lang_with_colno = lang_with_colno_list[k]
-          cell = cells[lang_with_colno.colno]
+        lang_with_colno_list.each do |lang_with_colno|
+          cell = cells[lang_with_colno.colno - 1]
           val = cell && cell.value
           cell_value = val.to_s
           lang_name = lang_with_colno.lang
@@ -108,7 +136,7 @@ module Applocale
     def to_value_key(value)
       if !value.nil? && value != ''
         new_value = value.to_s
-        if ValidKey.is_validkey(@setting.platform, new_value)
+        if ValidKey.is_validkey(@platform, new_value)
           return new_value
         else
           rowinfo = ParseXLSXModule::RowInfo.new(nil, nil, value)
@@ -125,20 +153,20 @@ module Applocale
       end
     end
 
-    def find_header(cells)
+    def find_header(sheetinfoobj, cells)
       keystr_with_colno = nil
       lang_with_colno_list = Array.new
       k_header_lang_dict = []
-      colno = 0
+      colno = 1
       cells.each{ |cell|
         value = cell && cell.value
         unless value.nil?
-          if value == @setting.keystr && keystr_with_colno.nil?
+          if value == sheetinfoobj.key_header && keystr_with_colno.nil?
             keystr_with_colno = ParseXLSXModule::KeyStrWithColNo.new(value, colno)
           else
-            @setting.langlist.each do |lang, info|
-              if value == info[:xlsheader] && k_header_lang_dict.index(lang).nil?
-                lang_with_colno_list.push(ParseXLSXModule::LangWithColNo.new(info[:xlsheader], lang, colno))
+            sheetinfoobj.lang_headers.each do |lang, keyforlang|
+              if value == keyforlang && k_header_lang_dict.index(lang).nil?
+                lang_with_colno_list.push(ParseXLSXModule::LangWithColNo.new(keyforlang, lang, colno))
                 k_header_lang_dict.push(lang)
               end
             end
@@ -146,7 +174,7 @@ module Applocale
         end
         colno += 1
       }
-      if !keystr_with_colno.nil? && lang_with_colno_list.length == @setting.langlist.length
+      if !keystr_with_colno.nil? && lang_with_colno_list.length == sheetinfoobj.lang_headers.length
         return {:keystr_colno => keystr_with_colno, :lang_colno => lang_with_colno_list}
       end
     end

data/lib/applocale/Core/ParseXLSX/parse_xlsx_module.rb

@@ -1,6 +1,21 @@
+
+
 module Applocale
 
+
   module ParseXLSXModule
+    class Helper
+      def self.collabel_to_colno(collabel)
+        if collabel.match(/^(\d)+$/)
+          return collabel.to_i
+        end
+        number = collabel.tr("A-Z", "1-9a-q").to_i(27)
+        number -= 1 if number > 27
+        return number
+      end
+    end
+
+
     class SheetContent
       attr_accessor :sheetname, :header_rowno, :keyStr_with_colno, :lang_with_colno_list, :rowinfo_list, :comment
 
@@ -52,7 +67,7 @@ module Applocale
       end
 
       def to_s
-        "sheetname = #{sheetname}, rowno = #{rowno+1}, key_str = #{key_str}, content_dict = #{content_dict}"
+        "sheetname = #{sheetname}, rowno = #{rowno}, key_str = #{key_str}, content_dict = #{content_dict}"
       end
 
     end
@@ -67,7 +82,7 @@ module Applocale
       end
 
       def to_s
-        "{header_str => #{header_str}, colno => #{colno+1}}"
+        "{header_str => #{header_str}, colno => #{colno}}"
       end
 
     end
@@ -82,10 +97,30 @@ module Applocale
       end
 
       def to_s
-        "{header_str => #{header_str}, lang => #{lang}, colno => #{colno+1}}"
+        "{header_str => #{header_str}, lang => #{lang}, colno => #{colno}}"
       end
 
     end
 
   end
-end
+end
+
+
+module Applocale
+  module Config
+    class SheetInfoByRow
+      def to_keyStrWithColNo(sheetcontent)
+        sheetcontent.header_rowno = self.row
+        keycolno = Applocale::ParseXLSXModule::Helper.collabel_to_colno(self.key_col)
+        sheetcontent.keyStr_with_colno = ParseXLSXModule::KeyStrWithColNo.new(nil, keycolno)
+        sheetcontent.lang_with_colno_list = Array.new
+        self.lang_cols.each do |lang, collabel|
+          colno = Applocale::ParseXLSXModule::Helper.collabel_to_colno(collabel)
+          obj = ParseXLSXModule::LangWithColNo.new(nil,lang, colno)
+          sheetcontent.lang_with_colno_list.push(obj)
+        end
+      end
+    end
+  end
+end
+

data/lib/applocale/Core/ParserStringFile/parse_localized_resource.rb

@@ -3,6 +3,7 @@ require File.expand_path('../../../Util/platform.rb', __FILE__)
 require File.expand_path('../../ParseXLSX/parse_xlsx_module', __FILE__)
 require File.expand_path('../parse_strings_file', __FILE__)
 require File.expand_path('../parse_xml_file', __FILE__)
+require File.expand_path('../../../Util/injection.rb', __FILE__)
 
 require 'rubyXL'
 require 'colorize'
@@ -10,32 +11,41 @@ require 'colorize'
 module Applocale
   class ParseLocalizedResource
     @skip_error = false
-    @setting = Setting
+    @platform
+    @xlsxpath
+    @langpathobj_list
+    @sheetobj_list
+    @injectobj
 
-    def initialize(skip_error = false)
+    def initialize(skip_error = false, platform, xlsxpath, langpathobj_list, sheetobj_list, rubycode)
       @skip_error = skip_error
-      @setting = Setting
-      FileUtils.mkdir_p(File.dirname(@setting.xlsxpath))
-      FileUtils.rm(@setting.xlsxpath) if File.exist? @setting.xlsxpath
-      keystr_with_colno = ParseXLSXModule::KeyStrWithColNo.new(@setting.keystr, 0)
-      lang_with_colno_list = Array.new
-      colno = 1
-      @setting.langlist.each do |key, langinfo|
-        langwith_colno = ParseXLSXModule::LangWithColNo.new(langinfo[:xlsheader], key, colno)
-        colno+=1
-        lang_with_colno_list.push(langwith_colno)
-      end
-      if @setting.platform == Platform::IOS
+      @platform = platform
+      @xlsxpath = xlsxpath
+      @langpathobj_list = langpathobj_list
+      @sheetobj_list = sheetobj_list
+      @injectobj = Applocale::Injection.load(rubycode)
+      startParse()
+    end
+
+    def startParse
+      puts "Start to Parse StringFile .... ".green
+
+      FileUtils.mkdir_p(File.dirname(@xlsxpath))
+      FileUtils.rm(@xlsxpath) if File.exist? @xlsxpath
+
+      sheetobj = @sheetobj_list[0]
+
+      if @platform == Platform::IOS
         result = self.parse_ios
-        write_to_xlsx(@setting.xlsxpath, keystr_with_colno, lang_with_colno_list, result[:errorlist], result[:content], result[:keylist])
+        write_to_xlsx(@xlsxpath, sheetobj, result[:errorlist], result[:content], result[:keylist])
       else
         result = self.parse_android
-        write_to_xlsx(@setting.xlsxpath, keystr_with_colno, lang_with_colno_list, result[:errorlist], result[:content], result[:keylist])
+        write_to_xlsx(@xlsxpath, sheetobj, result[:errorlist], result[:content], result[:keylist])
       end
     end
 
     def parse_ios
-      result = ParseStringsFile.new
+      result = ParseStringsFile.new(@platform, @langpathobj_list, @injectobj)
       errorlist = result.errorlist
       content = result.strings_keys
       keylist = result.keys_list
@@ -43,30 +53,47 @@ module Applocale
     end
 
     def parse_android
-      result = ParseXMLFile.new
+      result = ParseXMLFile.new(@platform, @langpathobj_list, @injectobj)
       errorlist = result.errorlist
       content = result.strings_keys
       keylist = result.keys_list
       return {:errorlist => errorlist, :content => content, :keylist => keylist}
     end
 
-    def write_to_xlsx(path, keystrwithColNo, langwithColNolist, errorlist, content, keylist)
+    def write_to_xlsx(path, sheetobj, errorlist, content, keylist)
       ErrorUtil::ParseLocalizedError::ParseLocalizedError.raiseArr(errorlist, !@skip_error)
       puts "Start write to file: \"#{path}\" ...".green
       workbook = RubyXL::Workbook.new
       worksheet = workbook.worksheets[0]
+      worksheet.sheet_name = sheetobj.sheetname
       rowno = 0
-      worksheet.add_cell(rowno, keystrwithColNo.colno, keystrwithColNo.header_str)
-      langwithColNolist.each do |langwithColNo|
-        worksheet.add_cell(rowno, langwithColNo.colno, langwithColNo.header_str)
+
+      keycolno = 0
+      langcolno_dict = {}
+
+      sheet_info_obj = sheetobj.obj
+      if sheet_info_obj.is_a? Applocale::Config::SheetInfoByHeader
+        worksheet.add_cell(rowno, keycolno, sheet_info_obj.key_header)
+        langcolno = keycolno + 1
+        sheet_info_obj.lang_headers.each do  |key, header|
+          worksheet.add_cell(rowno, langcolno, header)
+          langcolno_dict[key] = langcolno
+          langcolno += 1
+        end
+        rowno+=1
+      elsif sheet_info_obj.is_a? Applocale::Config::SheetInfoByRow
+        rowno = sheet_info_obj.row - 1
+        keycolno = Applocale::ParseXLSXModule::Helper.collabel_to_colno(sheet_info_obj.key_col) - 1
+        sheet_info_obj.lang_cols.each do |lang, collabel|
+          langcolno_dict[lang] = Applocale::ParseXLSXModule::Helper.collabel_to_colno(collabel) - 1
+        end
       end
-      rowno+=1
+
       keylist.each do |key|
-        worksheet.add_cell(rowno, keystrwithColNo.colno, key)
+        worksheet.add_cell(rowno, keycolno, key)
         unless content[key].nil?
-          langwithColNolist.each do |langwithColNo|
-            lang = langwithColNo.lang.to_s
-            worksheet.add_cell(rowno, langwithColNo.colno, content[key][lang][:value]) if !content[key][lang].nil? && !content[key][lang][:value].nil?
+          langcolno_dict.each do |lang, colno|
+            worksheet.add_cell(rowno, colno, content[key][lang][:value]) if !content[key][lang].nil? && !content[key][lang][:value].nil?
           end
         end
         rowno+=1