| #************************************************************** | |
| # | |
| # Licensed to the Apache Software Foundation (ASF) under one | |
| # or more contributor license agreements. See the NOTICE file | |
| # distributed with this work for additional information | |
| # regarding copyright ownership. The ASF licenses this file | |
| # to you under the Apache License, Version 2.0 (the | |
| # "License"); you may not use this file except in compliance | |
| # with the License. You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, | |
| # software distributed under the License is distributed on an | |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| # KIND, either express or implied. See the License for the | |
| # specific language governing permissions and limitations | |
| # under the License. | |
| # | |
| #************************************************************** | |
| from optparse import OptionParser | |
| from sdf import SdfData | |
| from pseudo import PseudoSet | |
| import sys | |
| import os | |
| import shutil | |
| class AbstractL10nTool: | |
| _options = {} | |
| _args = "" | |
| _resource_type = "" | |
| _source_language = "en-US" | |
| ##### Implement these abstract methods | |
| ##### Nameing scheme for the output files | |
| def get_outputfile_format_str(self): | |
| # filename,fileNoExt,language,extension,pathPrefix,pathPostFix,path | |
| #return "{path}/{fileNoExt}_{language}.{extension}" | |
| return self._options.pattern | |
| ################################# Merge single files ########################################### | |
| ##### Merge a single file | |
| def merge_file(self, inputfilename, outputfilename, parsed_file_ref, lang, is_forced_lang, sdfdata): | |
| pass | |
| ##### Helper for parse-once-use-often like parsing a xml file is needed implement it here | |
| def parse_file(self, filename): | |
| return None | |
| ################### Merge one big file containing all strings in all languages ################# | |
| def merge_one_big_file(self, inputfile, outputfilename, parsed_file_ref, lang, sdfdata): | |
| pass | |
| ################### Extract a single File ###################################################### | |
| def extract_file(self, inputfile): | |
| pass | |
| ################################################################################################ | |
| def format_outputfile(self, filename, language): | |
| extension = filename[filename.rfind('.')+1:] | |
| file = filename[:filename.rfind('.')] | |
| # Python 2.3.x friendly | |
| return self.get_outputfile_format_str().replace('[', '%(').replace(']',')s') % \ | |
| { 'filename': filename, 'fileNoExt': file, 'language': language, 'extension': extension, 'path_prefix': self._options.path_prefix, | |
| 'path_postfix': self._options.path_postfix, 'path': self.get_path() } | |
| #return self.get_outputfile_format_str().replace('[', '{').replace(']','}').format( | |
| # filename=filename, fileNoExt=file, language=language, extension=extension, path_prefix=self._options.path_prefix, | |
| # path_postfix=self._options.path_postfix, path=self.get_path()) | |
| def get_path(self): | |
| if self._options.outputfile.find('/') == -1: | |
| return "" | |
| else: | |
| return self._options.outputfile[:self._options.outputfile.rfind('/')] | |
| def merge(self, sdfdata): | |
| langset,forcedset, foundset = PseudoSet(), PseudoSet() , PseudoSet() | |
| if self._options.languages: | |
| langset = PseudoSet(self._options.languages) | |
| if self._options.forcedlanguages: | |
| forcedset = PseudoSet(self._options.forcedlanguages) | |
| if sdfdata.get_languages_found_in_sdf(): | |
| foundset = sdfdata.get_languages_found_in_sdf() | |
| if self.has_multi_inputfiles(): | |
| filelist = self.read_inputfile_list() | |
| else: | |
| filelist = self._options.inputfile | |
| for inputfile in filelist: | |
| ref = self.parse_file(inputfile) | |
| # Don't write that files if there is no l10n present | |
| if ((langset & foundset) - forcedset): # all langs given and found in sdf without enforced | |
| [self.merge_file(inputfile,self.format_outputfile(inputfile, lang), ref, lang, False, sdfdata) for lang in ((langset & foundset) - forcedset)] | |
| # Always write those files even if there is no l10n available | |
| if forcedset: # all enforced langs | |
| [self.merge_file(inputfile, self.format_outputfile(inputfile, lang), ref, lang, True, sdfdata) for lang in forcedset] | |
| # In case a big file have to be written | |
| if ((langset & foundset) | forcedset): # all langs given ,found in sdf and enforced ones | |
| self.merge_one_big_file(inputfile, self.format_outputfile(inputfile, lang), ref, ((langset & foundset) | forcedset), sdfdata) | |
| def has_multi_inputfiles(self): | |
| return self._options.inputfile[0] == '@' | |
| def copy_file(self, inputfilename, outputfilename): | |
| try: | |
| os.remove(outputfilename) | |
| except: | |
| pass | |
| try: | |
| os.remove(outputfilename) | |
| except: | |
| pass | |
| try: | |
| shutil.copy(inputfilename, outputfilename) | |
| except IOError: | |
| print("ERROR: Can not copy file '" + inputfilename + "' to " + "'" + outputfilename + "'") | |
| sys.exit(-1) | |
| def extract(self): | |
| try: | |
| f = open(self._options.outputfile, "w+", encoding="utf-8") | |
| f.write(self.extract_file(self._options.inputfile)) | |
| except IOError: | |
| print("ERROR: Can not write file " + self._options.outputfile) | |
| else: | |
| f.close() | |
| # Parse the common options | |
| def parse_options(self): | |
| parser = OptionParser() | |
| parser.add_option("-i", "--inputfile", dest="inputfile", metavar="FILE", help="resource file to read" ) | |
| parser.add_option("-o", "--outputfile", dest="outputfile", metavar="FILE", help="extracted sdf or merged file" ) | |
| parser.add_option("-m", "--inputsdffile", dest="input_sdf_file", metavar="FILE", help="merge this sdf file" ) | |
| parser.add_option("-x", "--pathprefix", dest="path_prefix", metavar="PATH", help="" ) | |
| parser.add_option("-y", "--pathpostfix", dest="path_postfix", metavar="PATH", help="" ) | |
| parser.add_option("-p", "--projectname", dest="project_name", metavar="NAME", help="" ) | |
| parser.add_option("-r", "--projectroot", dest="project_root", metavar="PATH", help="" ) | |
| parser.add_option("-f", "--forcedlanguages", dest="forcedlanguages", metavar="ISOCODE[,ISOCODE]", help="Always merge those langs even if no l10n is available for those langs" ) | |
| parser.add_option("-l", "--languages", dest="languages", metavar="ISOCODE[,ISOCODE]", help="Merge those langs if l10n is found for each") | |
| parser.add_option("-s", "--pattern", dest="pattern", metavar="", help="" ) | |
| parser.add_option("-q", "--quiet", action="store_true", dest="quietmode", help="",default=False) | |
| (self._options, self.args) = parser.parse_args() | |
| # -l "de,pr,pt-BR" => [ "de" , "pt" , "pt-BR" ] | |
| parse_complex_arg = lambda arg: arg.split(",") | |
| if self._options.forcedlanguages: | |
| self._options.forcedlanguages = parse_complex_arg(self._options.forcedlanguages) | |
| if self._options.languages: | |
| self._options.languages = parse_complex_arg(self._options.languages) | |
| self.test_options() | |
| def __init__(self): | |
| self.parse_options() | |
| if self._options.input_sdf_file != None and len(self._options.input_sdf_file): | |
| sdfdata = SdfData(self._options.input_sdf_file) | |
| sdfdata.read() | |
| self.merge(sdfdata) | |
| else: | |
| self.extract() | |
| def make_dirs(self, filename): | |
| dir = filename[:filename.rfind('/')] | |
| if os.path.exists(dir): | |
| if os.path.isfile(dir): | |
| print("ERROR: There is a file '"+dir+"' where I want create a directory") | |
| sys.exit(-1) | |
| else: | |
| return | |
| else: | |
| try: | |
| os.makedirs(dir) | |
| except IOError: | |
| print("Error: Can not create dir " + dir) | |
| sys.exit(-1) | |
| def test_options(self): | |
| opt = self._options | |
| is_valid = lambda x: x != None and len(x) > 0 | |
| return is_valid(opt.project_root) and is_valid(opt.project_name) and is_valid(opt.languages) and \ | |
| ( is_valid(opt.inputfile) and (( is_valid(opt.path_prefix) and is_valid(opt.path_postfix) ) or is_valid(opt.outputfile)) and \ | |
| ( ( is_valid(opt.input_sdf_file) and ( is_valid(opt.outputfile) or ( is_valid(opt.path_prefix) and is_valid(opt.path_postfix) ) or \ | |
| ( is_valid(opt.inputfile) and is_valid(opt.outputFile)) )))) | |
| print("Strange options ...") | |
| sys.exit( -1 ) | |
| def read_inputfile_list(self): | |
| if self.has_multi_inputfiles(): | |
| lines = [] | |
| try: | |
| f = open(self._options.inputfile[1:], "r") | |
| lines = [line.strip('\n') for line in f.readlines()] | |
| except IOError: | |
| print("ERROR: Can not read file list " + self._options.inputfile[2:]) | |
| sys.exit(-1) | |
| else: | |
| f.close() | |
| return lines | |
| def get_filename_string(self, inputfile): | |
| absfile = os.path.realpath(os.path.abspath(inputfile)) | |
| absroot = os.path.realpath(os.path.abspath(self._options.project_root)) | |
| return absfile[len(absroot)+1:].replace('/','\\') |