From 36cce3a86e67c9cda58e148f0b9f82def8759fe8 Mon Sep 17 00:00:00 2001 From: matic_t Date: Mon, 24 Aug 2020 09:03:14 -0700 Subject: [PATCH] don't delete unsupported schema on homonymy and string data in head --- src/export.py | 101 ++++++++++++++++++++------------ src/message/common_accessors.py | 13 ++-- src/message/delete_messages.py | 4 +- src/message/simple_edits.py | 10 ++++ src/model/entry.py | 2 +- src/view/modal_templates.py | 9 +-- src/view/modals.py | 1 + 7 files changed, 91 insertions(+), 49 deletions(-) diff --git a/src/export.py b/src/export.py index c5be07d..efc1083 100644 --- a/src/export.py +++ b/src/export.py @@ -7,79 +7,92 @@ def export_to_xml(model): serializer = __new__(XMLSerializer()) return serializer.serializeToString(xml_document) - def export_entry(entry): parser = __new__(DOMParser()) doc = parser.parseFromString("", "text/xml") entry_xml = doc.firstChild # create head - head = doc.createElement("head") - entry_xml.appendChild(head) + head = entry.original_xml.querySelector("head") + if head is None: + head = doc.createElement("head") + entry.original_xml.appendChild(head) +# entry_xml.appendChild(head.cloneNode(True)) - status = doc.createElement("status") + status = _original_xml_query_selector("head status", entry, doc) status.textContent = entry.status - head.appendChild(status) +# head.appendChild(status.cloneNode(True)) + + - headword = doc.createElement("headword") - headword_lemma = doc.createElement("lemma") +# headword = doc.createElement("headword") +# headword_lemma = doc.createElement("lemma") -# headword_lemma = entry.original_xml.querySelector("head headword lemma") + headword = _original_xml_query_selector("head headword", entry, doc) + headword_lemma = _original_xml_query_selector("head headword lemma", entry, doc) headword_lemma.textContent = entry.headword if entry.headword_type is not None: headword_lemma.setAttribute("type", entry.headword_type) if entry.headword_audio is not None: headword_lemma.setAttribute("audio", entry.headword_audio) - headword.appendChild(headword_lemma) - head.appendChild(headword) - homonymy = doc.createElement("homonymy") - headword.appendChild(homonymy) +# headword.appendChild(headword_lemma.cloneNode(True)) +# head.appendChild(headword.cloneNode(True)) + homonymy = _original_xml_query_selector("head headword homonymy", entry, doc) + original_homonymy = entry.original_xml.querySelectorAll("head headword homonymy homonymyFeature") +# todo: How do you know which one is changed/created anew etc - Perhaps go with position in array and save it in homonymy object or something? for hFeature in entry.homonymy: feature = doc.createElement("homonymyFeature") + if hFeature.id >= 0: + feature = original_homonymy[hFeature.id] + else: + homonymy.appendChild(feature) + feature.textContent = hFeature.value -# Can't use hFeature.name, because Python has name reserver and so it becomes py_name in JS +# Can't use hFeature.name, because Python has name reserved and so it becomes py_name in JS feature.setAttribute("name", hFeature["name"]) - homonymy.appendChild(feature) + + console.log(homonymy) +# console.log(entry.original_homonymy.querySelector("head headwo") # if({}) works uncorrectly in transcrypt if len(entry.lexical_unit) > 0: - lexunit = doc.createElement("lexicalUnit") + lexunit = _original_xml_query_selector("head lexicalUnit", entry, doc) +# lexunit = doc.createElement("lexicalUnit") lexunit.setAttribute("id", entry.lexical_unit["id"]) lexunit.setAttribute("type", "single") - lexeme = doc.createElement("lexeme") + lexeme = _original_xml_query_selector("head lexicalUnit lexeme", entry, doc) +# lexeme = doc.createElement("lexeme") lexeme.setAttribute("lexical_unit_lexeme_id", entry.lexical_unit["id"]) lexeme.textContent = entry.lexical_unit["text"] - lexunit.appendChild(lexeme) - head.appendChild(lexunit) +# lexunit.appendChild(lexeme.cloneNode(True)) +# head.appendChild(lexunit.cloneNode(True)) # Example of keeping original xml and adding changes to it only - grammar_category = entry.original_xml.querySelector("head grammar category") - if grammar_category is None: - grammar = doc.createElement("grammar") - grammar_category = doc.createElement("category") - grammar.appendChild(grammar_category) - entry.original_xml.querySelector("head").appendChild(grammar_category) - + grammar = _original_xml_query_selector("head grammar", entry, doc) + grammar_category = _original_xml_query_selector("head grammar category", entry, doc) grammar_category.textContent = entry.grammar - head.appendChild(entry.original_xml.querySelector("head grammar")) - +# head.appendChild(grammar.cloneNode(True)) + console.log(entry.original_xml) if len(entry.measure) > 0: - measure_list = doc.createElement("measureList") - measure = doc.createElement("measure") + measure_list = _original_xml_query_selector("head measureList", entry, doc) + measure = _original_xml_query_selector("head measureList measure", entry, doc) + +# measure_list = doc.createElement("measureList") +# measure = doc.createElement("measure") measure.setAttribute("source", entry.measure["source"]) measure.setAttribute("type", entry.measure["type"]) measure.textContent = entry.measure["text"] - measure_list.appendChild(measure) - head.appendChild(measure_list) +# head.appendChild(measure_list) +# Same problem as homonymy variants = doc.createElement("variantList") head.appendChild(variants) @@ -88,8 +101,9 @@ def export_entry(entry): variant.textContent = v variants.appendChild(variant) +# relist = _original_xml_query_selector("head relatedEntryList", entry, doc) relist = doc.createElement("relatedEntryList") - head.appendChild(relist) + head.appendChild(relist.cloneNode(True)) for re in entry.related_entries: relateEntry = doc.createElement("relatedEntry") @@ -98,21 +112,25 @@ def export_entry(entry): head.appendChild(_export_label_list(doc, entry.labels)) - comment = doc.createElement("comment") +# comment = doc.createElement("comment") + comment = _original_xml_query_selector("head comment", entry, doc) comment.textContent = entry.comment - head.appendChild(comment) +# head.appendChild(comment.cloneNode(True)) # now lets do body - body = doc.createElement("body") - entry_xml.appendChild(body) + + body = entry.original_xml.querySelector("body") + if body is None: + body = doc.createElement("body") + entry.original_xml.appendChild(body) +# entry_xml.appendChild(body) sense_list = doc.createElement("senseList") - body.appendChild(sense_list) for sense in entry.senses: sense_list.appendChild(export_sense(doc, sense)) - return doc + return entry.original_xml def export_sense(doc, sense): @@ -192,3 +210,10 @@ def _export_label_list(doc, lst): label_el.setAttribute('type', key) result.appendChild(label_el) return result + +def _original_xml_query_selector(selector, entry, doc, parent_selector = selector.rsplit(' ', 1)[0]): + query = entry.original_xml.querySelector(selector) + if query is None: + query = doc.createElement(selector.rsplit(' ', 1)[1]) + entry.original_xml.querySelector(parent_selector).appendChild(query) + return query diff --git a/src/message/common_accessors.py b/src/message/common_accessors.py index f71e6e9..b187e82 100644 --- a/src/message/common_accessors.py +++ b/src/message/common_accessors.py @@ -13,16 +13,19 @@ def generic_list_getter(): def double_list_getter(firstParameter, secondParameter, allowEmptyField = False): result = [] for row in document.getElementsByClassName("double-list-row"): - firstValue = row.querySelector("." + firstParameter + "-input").value - secondValue = row.querySelector("." + secondParameter + "-input").value + output = {} + output[firstParameter] = row.querySelector("." + firstParameter + "-input").value + output[secondParameter] = row.querySelector("." + secondParameter + "-input").value + if row.hasAttribute("data-id"): + output.id = int(row.getAttribute("data-id")) - if (allowEmptyField is False and '' in [firstValue, secondValue]): + if (allowEmptyField is False and '' in [output[firstParameter], output[secondParameter]]): continue - if (allowEmptyField is True and all('' == value or value.isspace() for value in [firstValue, secondValue])): + if (allowEmptyField is True and all('' == value or value.isspace() for value in [output[firstParameter], output[secondParameter]])): continue - result.append({firstParameter: firstValue, secondParameter: secondValue}) + result.append(output) return result diff --git a/src/message/delete_messages.py b/src/message/delete_messages.py index 19635ec..ad9cf5e 100644 --- a/src/message/delete_messages.py +++ b/src/message/delete_messages.py @@ -21,7 +21,9 @@ class DeleteRelatedEntries(DeleteVariants): class DeleteHomonymy(NoReset): def update_model(self, model): - for el in document.getElementsByClassName("list-adder-input"): + for el in document.getElementsByClassName("name-input"): + el.value = "" + for el in document.getElementsByClassName("value-input"): el.value = "" diff --git a/src/message/simple_edits.py b/src/message/simple_edits.py index 927c819..d6a953e 100644 --- a/src/message/simple_edits.py +++ b/src/message/simple_edits.py @@ -91,6 +91,16 @@ class EditVariants(Message): class EditHomonymy(Message): def update_model(self, model): homonymy = common_accessors.double_list_getter("value", "name") + + keptHFeatureIds = [feature.id for feature in homonymy] + for index, feature in enumerate(model.entry.original_xml.querySelectorAll("head headword homonymy homonymyFeature")): + if (index not in keptHFeatureIds): + feature.remove() + + for index, feature in enumerate(homonymy): + if (feature.id >= 0): + feature.id = index + model.entry.homonymy = homonymy diff --git a/src/model/entry.py b/src/model/entry.py index 5e60489..dc85cec 100644 --- a/src/model/entry.py +++ b/src/model/entry.py @@ -40,7 +40,7 @@ class Entry(Data): self.grammar = grammar.textContent if grammar else "" self.comment = comment.textContent if comment else "" self.variants = [v.textContent for v in entry_xml.querySelectorAll("head variantList variant")] - self.homonymy = [{"value": v.textContent, "name": v.getAttribute("name")} for v in entry_xml.querySelectorAll("head headword homonymy homonymyFeature ")] + self.homonymy = [{"value": v.textContent, "name": v.getAttribute("name"), "id": index} for index, v in enumerate(entry_xml.querySelectorAll("head headword homonymy homonymyFeature "))] self.related_entries = [re.textContent for re in entry_xml.querySelectorAll("head relatedEntryList relatedEntry")] lex_unit = entry_xml.querySelector("lexical_unit lexeme,lexicalUnit lexeme") diff --git a/src/view/modal_templates.py b/src/view/modal_templates.py index 562deb6..e56c8df 100644 --- a/src/view/modal_templates.py +++ b/src/view/modal_templates.py @@ -48,9 +48,10 @@ def generic_list_editor(title, element_list_getter): return content def homonymy_editor(title, current_labels): - def split_line2(left, right): + def split_line2(left, right, labelId): cls = "flex.two{}".format(".double-list-row") - return h("div.{}".format(cls), {}, [ + isId = {"attrs": {"data-id": labelId}} if labelId >= 0 else {} + return h("div.{}".format(cls), isId, [ h("div.half", {}, left), h("div.half", {}, right)]) content = [h("p", {}, title)] @@ -58,11 +59,11 @@ def homonymy_editor(title, current_labels): name = [] value = [] name.append(h("label", {"attrs": {"for": i}}, "Name:")) - name.append(h("input.name-input", {"props": {"type": "text", "value": feature["name"], "id": i}}, "")) + name.append(h("input.name-input", {"props": {"type": "text", "value": feature["name"], "id": i, "data-id": feature.id}}, "")) value.append(h("label", {"attrs": {"for": i + "-value"}}, "Value:")) value.append(h("input.value-input", {"props": {"type": "text", "value": feature["value"], "id": i + "-value"}}, "")) - content.append(split_line2(name, value)) + content.append(split_line2(name, value, feature.id)) content.append(h("button", {"on": {"click": message.msg(message.AddToGenericList, current_labels)}}, "+")) return content diff --git a/src/view/modals.py b/src/view/modals.py index c6fd6c1..9470e5d 100644 --- a/src/view/modals.py +++ b/src/view/modals.py @@ -100,6 +100,7 @@ def edit_variants(entry): def edit_homonymy(entry): hget = lambda: entry.copy().homonymy + console.log(hget) content = homonymy_editor("Homonymy", hget) return modal_template(content, "Add or remove homonymy features", (message.EditHomonymy,), (message.DeleteHomonymy,))