def __CreateFileNode(self, translations_node, lang):
"""Creates and initializes the <file> elements.
File elements provide information on the location of translation files
(xtbs)
"""
xtb_file = os.path.normpath(
os.path.join(self.xtb_dir, '%s_%s.xtb' % (self.name, lang)))
fnode = node_io.FileNode()
fnode.StartParsing(u'file', translations_node)
fnode.HandleAttribute('path', xtb_file)
fnode.HandleAttribute('lang', lang)
fnode.EndParsing()
translations_node.AddChild(fnode)
return fnode
def testGetPath(self):
root = misc.GritNode()
root.StartParsing(u'grit', None)
root.HandleAttribute(u'latest_public_release', u'0')
root.HandleAttribute(u'current_release', u'1')
root.HandleAttribute(u'base_dir', r'..\resource')
translations = empty.TranslationsNode()
translations.StartParsing(u'translations', root)
root.AddChild(translations)
file_node = node_io.FileNode()
file_node.StartParsing(u'file', translations)
file_node.HandleAttribute(u'path', r'flugel\kugel.pdf')
translations.AddChild(file_node)
root.EndParsing()
self.failUnless(
root.ToRealPath(file_node.GetInputPath()) == util.normpath(
os.path.join(r'../resource', r'flugel/kugel.pdf')))
def Update(self, other, load_translations=True):
self.active_other_files.update(other.active_source_files)
if "outputs" in other and "outputs" not in self:
self["outputs"] = other["outputs"]
elif "outputs" in other:
top_node = self["outputs"]
for node in other["outputs"].ActiveDescendants():
if not isinstance(node, node_io.OutputNode):
continue
top_node.AddChild(node)
node.parent = top_node
if "releases" in other and "releases" not in self:
self["releases"] = other["releases"]
if "includes" in other and "includes" not in self:
self["includes"] = other["includes"]
self.setdefault("includes", {})
for name, seq_node in other.get("include-files", {}).items():
#seq_node[1].attrs["vivaldi-added"]="1"
if self.keep_sequence:
self.__replace_node(seq_node[1], self["includes"])
if name in self.get("include-files", {}):
self["include-files"][name] = (self["include-files"][name][0],
seq_node[1])
else:
self.setdefault("include-files", {})[name] = seq_node
if "messages" in other and "messages" not in self:
self["messages"] = other["messages"]
self.setdefault("message-entries", {})
for name, seq_node in other.get("message-entries", {}).items():
#seq_node[1].attrs["vivaldi-added"]="1"
if self.keep_sequence:
self.__replace_node(seq_node[1], self["messages"])
if name in self.get("message-entries", {}):
if load_translations:
new_clique = seq_node[1].GetCliques()[0].clique
old_clique = self["message-entries"][name][1].GetCliques(
)[0].clique
for lang in old_clique:
if lang not in new_clique:
new_clique[lang] = old_clique[lang]
self["message-entries"][name] = (
self["message-entries"][name][0], seq_node[1])
else:
self.setdefault("message-entries", {})[name] = seq_node
if "structures" in other and "structures" not in self:
self["structures"] = other["structures"]
self.setdefault("structure-entries", {})
for name, seq_node in other.get("structure-entries", {}).items():
#seq_node[1].attrs["vivaldi-added"]="1"
if self.keep_sequence:
self.__replace_node(seq_node[1], self["structures"])
if name in self["structure-entries"]:
self["structure-entries"][name] = (
self["structure-entries"][name][0], seq_node[1])
else:
self["structure-entries"][name] = seq_node
translations_node = None
for lnode in sorted(list(
recursive_iter_gritnode(self.resources["resources"],
node_io.FileNode)),
key=lambda x: x.GetLang()):
lang = lnode.GetLang()
if lang == "en" or lang == "x-P-pseudo":
continue
if lang in self.translation_names:
continue
if "generated_translations" not in self:
translations_node = empty.TranslationsNode()
translations_node.name = "translations"
old_top = self.get("translations", other.get("translations"))
translations_node.attrs = dict(old_top.attrs)
self["generated_translations"] = translations_node
new_node = node_io.FileNode()
new_node.name = "file"
#print self.translation_dir
filename = os.path.join(self.translation_dir, self.filename_base +
"_" + lang + ".xtb").replace("\\", "/")
self.translation_names[lang] = filename
new_node.attrs["path"] = filename
new_node.attrs["lang"] = lang
translations_node.AddChild(new_node)
new_node.parent = translations_node
def Load(self,
filename,
params={},
output_file_name=None,
extra_languages=None,
load_translations=True):
self.filename_base = os.path.splitext(output_file_name
or os.path.basename(filename))[0]
self.orig_filename_base = os.path.splitext(
os.path.basename(filename))[0]
self.filedir = os.path.dirname(filename)
self.resources = self.__load_resource(
filename,
params,
extra_languages=extra_languages,
load_translations=load_translations)
#self.all_source_files.add(filename)
file_list = ScanDir(self.filedir)
for x in file_list:
#print >>sys.stderr, "Adding", x, ":", x[0], x.startswith(".")
if x.startswith("."):
raise Exception(x)
self.all_source_files.update(file_list)
self.active_source_files.update(file_list)
self["grit"] = dict(self.resources["resources"].attrs)
if "outputs" in self.resources["nodes"]["internals"]:
new_top = empty.OutputsNode()
new_top.name = "outputs"
_seq, old_top = self.resources["nodes"]["internals"]["outputs"][0]
new_top.attrs = dict(old_top.attrs)
for old_node in iter_gritnode(old_top, node_io.OutputNode):
#if (self.orig_filename_base != self.filename_base and
# old_node.attrs.get("type", None) == "data_package"):
# old_node.attrs["filename"] = old_node.attrs["filename"].replace(
# self.orig_filename_base+"_", self.filename_base+"_")
#if self.orig_filename_base == "components_google_chrome_strings":
# print >>sys.stderr, old_node.attrs["filename"]
new_top.AddChild(old_node)
old_node.parent = new_top
self["outputs"] = new_top
if "translations" in self.resources["nodes"]["internals"]:
new_top = empty.TranslationsNode()
new_top.name = "translations"
_seq, old_top = self.resources["nodes"]["internals"][
"translations"][0]
new_top.attrs = dict(old_top.attrs)
for old_node in recursive_iter_gritnode(
self.resources["resources"], node_io.FileNode):
new_node = node_io.FileNode()
new_node.name = "file"
new_node.attrs = dict(old_node.attrs)
if "path" in new_node.attrs:
self.all_source_files.add(new_node.attrs["path"].replace(
"\\", "/"))
new_node.attrs["path"] = os.path.join(
os.getcwd(),
old_node.ToRealPath(old_node.GetInputPath()))
new_top.AddChild(new_node)
new_node.parent = new_top
self["translations"] = new_top
if "release" in self.resources["nodes"]["internals"]:
new_release = misc.ReleaseNode()
new_release.name = "release"
_seq, old_top = self.resources["nodes"]["internals"]["release"][0]
new_release.attrs = dict(old_top.attrs)
self["release"] = new_release
if "includes" in self.resources["nodes"]["internals"]:
_seq, old_top = self.resources["nodes"]["internals"]["includes"][0]
if self.keep_sequence:
new_top = old_top
self.__remove_part_nodes(new_top)
else:
new_top = empty.IncludesNode()
new_top.name = "includes"
new_top.attrs = dict(old_top.attrs)
self["includes"] = new_top
self["include-files"] = {}
for _seq, old_node in sorted([
x for x in self.resources["nodes"].values()
if isinstance(x, tuple)
and isinstance(x[1], include.IncludeNode)
]):
new_node = include.IncludeNode()
new_node.name = "include"
new_node.attrs = dict(old_node.attrs)
if "file" in new_node.attrs:
old_file = new_node.attrs["file"].replace("\\", "/")
new_node.attrs["file"] = old_file
self._AddFile(old_file)
self["include-files"][new_node.attrs["name"]] = (_seq,
new_node)
if "messages" in self.resources["nodes"]["internals"]:
_seq, old_top = self.resources["nodes"]["internals"]["messages"][0]
if self.keep_sequence:
new_top = old_top
self.__remove_part_nodes(new_top)
else:
new_top = empty.MessagesNode()
new_top.name = "messages"
new_top.attrs = dict(old_top.attrs)
self["messages"] = new_top
self["message-entries"] = {}
for _seq, old_node in sorted([
x for x in self.resources["nodes"].values()
if isinstance(x, tuple)
and isinstance(x[1], message.MessageNode)
]):
#if old_node.GetCliques():
# print old_node.GetCliques()[0].MessageForLanguage("no").GetPresentableContent()
self["message-entries"][old_node.attrs["name"]] = (_seq,
old_node)
if "structures" in self.resources["nodes"]["internals"]:
_seq, old_top = self.resources["nodes"]["internals"]["structures"][
0]
if self.keep_sequence:
new_top = old_top
self.__remove_part_nodes(new_top)
else:
new_top = empty.StructuresNode()
new_top.name = "structures"
new_top.attrs = dict(old_top.attrs)
self["structures"] = new_top
self["structure-entries"] = {}
for _seq, old_node in sorted([
x for x in self.resources["nodes"].values()
if isinstance(x, tuple)
and isinstance(x[1], structure.StructureNode)
]):
if self.keep_sequence:
new_node = old_node
else:
new_node = structure.StructureNode()
new_node.name = "structure"
new_node.attrs = dict(old_node.attrs)
if "file" in new_node.attrs:
old_file = new_node.attrs["file"].replace("\\", "/")
new_node.attrs["file"] = old_file
self._AddFile(old_file)
self["structure-entries"][new_node.attrs["name"]] = (_seq,
new_node)
