| #************************************************************** |
| # |
| # 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+") |
| 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('/','\\') |
