| #!/usr/bin/env python |
| ############################################################################# |
| ## |
| ## Copyright (C) 2016 The Qt Company Ltd. |
| ## Contact: https://www.qt.io/licensing/ |
| ## |
| ## This file is part of the test suite of the Qt Toolkit. |
| ## |
| ## $QT_BEGIN_LICENSE:GPL-EXCEPT$ |
| ## Commercial License Usage |
| ## Licensees holding valid commercial Qt licenses may use this file in |
| ## accordance with the commercial license agreement provided with the |
| ## Software or, alternatively, in accordance with the terms contained in |
| ## a written agreement between you and The Qt Company. For licensing terms |
| ## and conditions see https://www.qt.io/terms-conditions. For further |
| ## information use the contact form at https://www.qt.io/contact-us. |
| ## |
| ## GNU General Public License Usage |
| ## Alternatively, this file may be used under the terms of the GNU |
| ## General Public License version 3 as published by the Free Software |
| ## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT |
| ## included in the packaging of this file. Please review the following |
| ## information to ensure the GNU General Public License requirements will |
| ## be met: https://www.gnu.org/licenses/gpl-3.0.html. |
| ## |
| ## $QT_END_LICENSE$ |
| ## |
| ############################################################################# |
| |
| import sys |
| import os |
| import xml.dom.minidom |
| |
| class DraftResolution: |
| # See http://www.unicode.org/cldr/process.html for description |
| unconfirmed = 'unconfirmed' |
| provisional = 'provisional' |
| contributed = 'contributed' |
| approved = 'approved' |
| _values = { unconfirmed : 1, provisional : 2, contributed : 3, approved : 4 } |
| def __init__(self, resolution): |
| self.resolution = resolution |
| def toInt(self): |
| return DraftResolution._values[self.resolution] |
| |
| class Error: |
| def __init__(self, msg): |
| self.msg = msg |
| def __str__(self): |
| return self.msg |
| |
| doc_cache = {} |
| def parseDoc(file): |
| if not doc_cache.has_key(file): |
| doc_cache[file] = xml.dom.minidom.parse(file) |
| return doc_cache[file] |
| |
| def findChild(parent, tag_name, arg_name=None, arg_value=None, draft=None): |
| for node in parent.childNodes: |
| if node.nodeType != node.ELEMENT_NODE: |
| continue |
| if node.nodeName != tag_name: |
| continue |
| if arg_value: |
| if not node.attributes.has_key(arg_name): |
| continue |
| if node.attributes[arg_name].nodeValue != arg_value: |
| continue |
| if draft: |
| if not node.attributes.has_key('draft'): |
| # if draft is not specified then it's approved |
| return node |
| value = node.attributes['draft'].nodeValue |
| value = DraftResolution(value).toInt() |
| exemplar = DraftResolution(draft).toInt() |
| if exemplar > value: |
| continue |
| return node |
| return False |
| |
| def codeMapsFromFile(file): |
| """Extract mappings of language, script and country codes to names. |
| |
| The file shall typically be common/main/en.xml, which contains a |
| localeDisplayNames element with children languages, scripts and |
| territories; each element in each of these has a code as its type |
| attribute and its name as element content. This returns a mapping |
| withe keys 'language', 'script' and 'country', each of which |
| has, as value, a mapping of the relevant codes to names. |
| """ |
| parent = findChild(findChild(parseDoc(file), 'ldml'), 'localeDisplayNames') |
| keys, result = {'languages': 'language', 'scripts': 'script', 'territories': 'country'}, {} |
| for src, dst in keys.items(): |
| child = findChild(parent, src) |
| data = result[dst] = {} |
| for elt in child.childNodes: |
| if elt.attributes and elt.attributes.has_key('type'): |
| key, value = elt.attributes['type'].value, elt.childNodes[0].wholeText |
| # Don't over-write previously-read data for an alt form: |
| if elt.attributes.has_key('alt') and data.has_key(key): |
| continue |
| data[key] = value |
| |
| return result |
| |
| def findTagsInFile(file, path): |
| doc = parseDoc(file) |
| |
| elt = doc.documentElement |
| tag_spec_list = path.split("/") |
| last_entry = None |
| for tag_spec in tag_spec_list: |
| tag_name = tag_spec |
| arg_name = 'type' |
| arg_value = '' |
| left_bracket = tag_spec.find('[') |
| if left_bracket != -1: |
| tag_name = tag_spec[:left_bracket] |
| arg_value = tag_spec[left_bracket+1:-1].split("=") |
| if len(arg_value) == 2: |
| arg_name = arg_value[0] |
| arg_value = arg_value[1] |
| else: |
| arg_value = arg_value[0] |
| elt = findChild(elt, tag_name, arg_name, arg_value) |
| if not elt: |
| return None |
| ret = [] |
| if elt.childNodes: |
| for node in elt.childNodes: |
| if node.attributes: |
| element = [node.nodeName, None] |
| element[1] = node.attributes.items() |
| ret.append(element) |
| else: |
| if elt.attributes: |
| element = [elt.nodeName, None] |
| element[1] = elt.attributes.items() |
| ret.append(element) |
| return ret |
| |
| def _findEntryInFile(file, path, draft=None, attribute=None): |
| doc = parseDoc(file) |
| |
| elt = doc.documentElement |
| tag_spec_list = path.split("/") |
| last_entry = None |
| for i in range(len(tag_spec_list)): |
| tag_spec = tag_spec_list[i] |
| tag_name = tag_spec |
| arg_name = 'type' |
| arg_value = '' |
| left_bracket = tag_spec.find('[') |
| if left_bracket != -1: |
| tag_name = tag_spec[:left_bracket] |
| arg_value = tag_spec[left_bracket+1:-1].split("=") |
| if len(arg_value) == 2: |
| arg_name = arg_value[0].replace("@", "").replace("'", "") |
| arg_value = arg_value[1] |
| else: |
| arg_value = arg_value[0] |
| alias = findChild(elt, 'alias') |
| if alias and alias.attributes['source'].nodeValue == 'locale': |
| path = alias.attributes['path'].nodeValue |
| aliaspath = tag_spec_list[:i] + path.split("/") |
| def resolve(x, y): |
| if y == '..': |
| return x[:-1] |
| return x + [y] |
| # resolve all dot-dot parts of the path |
| aliaspath = reduce(resolve, aliaspath, []) |
| # remove attribute specification that our xpathlite doesnt support |
| aliaspath = map(lambda x: x.replace("@type=", "").replace("'", ""), aliaspath) |
| # append the remaining path |
| aliaspath = aliaspath + tag_spec_list[i:] |
| aliaspath = "/".join(aliaspath) |
| # "locale" aliases are special - we need to start lookup from scratch |
| return (None, aliaspath) |
| elt = findChild(elt, tag_name, arg_name, arg_value, draft) |
| if not elt: |
| return ("", None) |
| if attribute is not None: |
| if elt.attributes.has_key(attribute): |
| return (elt.attributes[attribute].nodeValue, None) |
| return (None, None) |
| try: |
| return (elt.firstChild.nodeValue, None) |
| except: |
| pass |
| return (None, None) |
| |
| def findAlias(file): |
| doc = parseDoc(file) |
| |
| alias_elt = findChild(doc.documentElement, "alias") |
| if not alias_elt: |
| return False |
| if not alias_elt.attributes.has_key('source'): |
| return False |
| return alias_elt.attributes['source'].nodeValue |
| |
| lookup_chain_cache = {} |
| parent_locales = {} |
| def _fixedLookupChain(dirname, name): |
| if lookup_chain_cache.has_key(name): |
| return lookup_chain_cache[name] |
| |
| # see http://www.unicode.org/reports/tr35/#Parent_Locales |
| if not parent_locales: |
| for ns in findTagsInFile(dirname + "/../supplemental/supplementalData.xml", "parentLocales"): |
| tmp = {} |
| parent_locale = "" |
| for data in ns[1:][0]: # ns looks like this: [u'parentLocale', [(u'parent', u'root'), (u'locales', u'az_Cyrl bs_Cyrl en_Dsrt ..')]] |
| tmp[data[0]] = data[1] |
| if data[0] == u"parent": |
| parent_locale = data[1] |
| parent_locales[parent_locale] = tmp[u"locales"].split(" ") |
| |
| items = name.split("_") |
| # split locale name into items and iterate through them from back to front |
| # example: az_Latn_AZ => [az_Latn_AZ, az_Latn, az] |
| items = list(reversed(map(lambda x: "_".join(items[:x+1]), range(len(items))))) |
| |
| for i in range(len(items)): |
| item = items[i] |
| for parent_locale in parent_locales.keys(): |
| for locale in parent_locales[parent_locale]: |
| if item == locale: |
| if parent_locale == u"root": |
| items = items[:i+1] |
| else: |
| items = items[:i+1] + _fixedLookupChain(dirname, parent_locale) |
| lookup_chain_cache[name] = items |
| return items |
| |
| lookup_chain_cache[name] = items |
| return items |
| |
| def _findEntry(base, path, draft=None, attribute=None): |
| if base.endswith(".xml"): |
| base = base[:-4] |
| (dirname, filename) = os.path.split(base) |
| |
| items = _fixedLookupChain(dirname, filename) |
| for item in items: |
| file = dirname + "/" + item + ".xml" |
| if os.path.isfile(file): |
| alias = findAlias(file) |
| if alias: |
| # if alias is found we should follow it and stop processing current file |
| # see http://www.unicode.org/reports/tr35/#Common_Elements |
| aliasfile = os.path.dirname(file) + "/" + alias + ".xml" |
| if not os.path.isfile(aliasfile): |
| raise Error("findEntry: fatal error: found an alias '%s' to '%s', but the alias file couldn't be found" % (filename, alias)) |
| # found an alias, recurse into parsing it |
| result = _findEntry(aliasfile, path, draft, attribute) |
| return result |
| (result, aliaspath) = _findEntryInFile(file, path, draft, attribute) |
| if aliaspath: |
| # start lookup again because of the alias source="locale" |
| return _findEntry(base, aliaspath, draft, attribute) |
| if result: |
| return result |
| return None |
| |
| def findEntry(base, path, draft=None, attribute=None): |
| file = base |
| if base.endswith(".xml"): |
| file = base |
| base = base[:-4] |
| else: |
| file = base + ".xml" |
| (dirname, filename) = os.path.split(base) |
| |
| result = None |
| while path: |
| result = _findEntry(base, path, draft, attribute) |
| if result: |
| return result |
| (result, aliaspath) = _findEntryInFile(dirname + "/root.xml", path, draft, attribute) |
| if result: |
| return result |
| if not aliaspath: |
| raise Error("findEntry: fatal error: %s: cannot find key %s" % (filename, path)) |
| path = aliaspath |
| |
| return result |
| |
