Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 244 insertions, 0 deletions

diff --git a/share/extensions/inkex/inx.py b/share/extensions/inkex/inx.py
new file mode 100644
index 0000000..2360bc6
--- /dev/null
+++ b/share/extensions/inkex/inx.py
@@ -0,0 +1,244 @@
+# coding=utf-8
+#
+# Copyright (C) 2018 Martin Owens <doctormo@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+"""
+Parsing inx files for checking and generating.
+"""
+
+import os
+from inspect import isclass
+from importlib import util
+from lxml import etree
+
+from .base import InkscapeExtension
+from .utils import Boolean
+
+NSS = {
+    "inx": "http://www.inkscape.org/namespace/inkscape/extension",
+    "inkscape": "http://www.inkscape.org/namespaces/inkscape",
+}
+SSN = {b: a for (a, b) in NSS.items()}
+
+
+class InxLookup(etree.CustomElementClassLookup):
+    """Custom inx xml file lookup"""
+
+    def lookup(
+        self, node_type, document, namespace, name
+    ):  # pylint: disable=unused-argument
+        if name == "param":
+            return ParamElement
+        return InxElement
+
+
+INX_PARSER = etree.XMLParser()
+INX_PARSER.set_element_class_lookup(InxLookup())
+
+
+class InxFile:
+    """Open an INX file and provide useful functions"""
+
+    name = property(lambda self: self.xml.get_text("name"))
+    ident = property(lambda self: self.xml.get_text("id"))
+    slug = property(lambda self: self.ident.split(".")[-1].title().replace("_", ""))
+    kind = property(lambda self: self.metadata["type"])
+    warnings = property(lambda self: sorted(list(set(self.xml.warnings))))
+
+    def __init__(self, filename):
+        if isinstance(filename, str) and "<" in filename:
+            filename = filename.encode("utf8")
+        if isinstance(filename, bytes) and b"<" in filename:
+            self.filename = None
+            self.doc = etree.ElementTree(etree.fromstring(filename, parser=INX_PARSER))
+        else:
+            self.filename = os.path.basename(filename)
+            self.doc = etree.parse(filename, parser=INX_PARSER)
+        self.xml = self.doc.getroot()
+        self.xml.warnings = []
+
+    def __repr__(self):
+        return f"<inx '{self.filename}' '{self.name}'>"
+
+    @property
+    def script(self):
+        """Returns information about the called script"""
+        command = self.xml.find_one("script/command")
+        if command is None:
+            return {}
+        return {
+            "interpreter": command.get("interpreter", None),
+            "location": command.get("location", None),
+            "script": command.text,
+        }
+
+    @property
+    def extension_class(self):
+        """Attempt to get the extension class"""
+        script = self.script.get("script", None)
+        if script is not None:
+            name = script[:-3].replace("/", ".")
+            spec = util.spec_from_file_location(name, script)
+            mod = util.module_from_spec(spec)
+            spec.loader.exec_module(mod)
+            for value in mod.__dict__.values():
+                if (
+                    "Base" not in name
+                    and isclass(value)
+                    and value.__module__ == name
+                    and issubclass(value, InkscapeExtension)
+                ):
+                    return value
+        return None
+
+    @property
+    def metadata(self):
+        """Returns information about what type of extension this is"""
+        effect = self.xml.find_one("effect")
+        output = self.xml.find_one("output")
+        inputs = self.xml.find_one("input")
+        data = {}
+        if effect is not None:
+            template = self.xml.find_one("inkscape:templateinfo")
+            if template is not None:
+                data["type"] = "template"
+                data["desc"] = self.xml.get_text(
+                    "templateinfo/shortdesc", nss="inkscape"
+                )
+                data["author"] = self.xml.get_text(
+                    "templateinfo/author", nss="inkscape"
+                )
+            else:
+                data["type"] = "effect"
+                data["preview"] = Boolean(effect.get("needs-live-preview", "true"))
+                data["objects"] = effect.get_text("object-type", "all")
+        elif inputs is not None:
+            data["type"] = "input"
+            data["extension"] = inputs.get_text("extension")
+            data["mimetype"] = inputs.get_text("mimetype")
+            data["tooltip"] = inputs.get_text("filetypetooltip")
+            data["name"] = inputs.get_text("filetypename")
+        elif output is not None:
+            data["type"] = "output"
+            data["dataloss"] = Boolean(output.get_text("dataloss", "false"))
+            data["extension"] = output.get_text("extension")
+            data["mimetype"] = output.get_text("mimetype")
+            data["tooltip"] = output.get_text("filetypetooltip")
+            data["name"] = output.get_text("filetypename")
+        return data
+
+    @property
+    def menu(self):
+        """Return the menu this effect ends up in"""
+
+        def _recurse_menu(parent):
+            for child in parent.xpath("submenu"):
+                yield child.get("name")
+                for subchild in _recurse_menu(child):
+                    yield subchild
+                break  # Not more than one menu chain?
+
+        menu = self.xml.find_one("effect/effects-menu")
+        return list(_recurse_menu(menu)) + [self.name]
+
+    @property
+    def params(self):
+        """Get all params at all levels"""
+        # Returns any params at any levels
+        return list(self.xml.xpath("//param"))
+
+
+class InxElement(etree.ElementBase):
+    """Any element in an inx file
+
+    .. versionadded:: 1.1"""
+
+    def set_warning(self, msg):
+        """Set a warning for slightly incorrect inx contents"""
+        root = self.get_root()
+        if hasattr(root, "warnings"):
+            root.warnings.append(msg)
+
+    def get_root(self):
+        """Get the root document element from any element descendent"""
+        if self.getparent() is not None:
+            return self.getparent().get_root()
+        return self
+
+    def get_default_prefix(self):
+        """Set default xml namespace prefix. If none is defined, set warning"""
+        tag = self.get_root().tag
+        if "}" in tag:
+            (url, tag) = tag[1:].split("}", 1)
+            return SSN.get(url, "inx")
+        self.set_warning("No inx xml prefix.")
+        return None  # no default prefix
+
+    def apply_nss(self, xpath, nss=None):
+        """Add prefixes to any xpath string"""
+        if nss is None:
+            nss = self.get_default_prefix()
+
+        def _process(seg):
+            if ":" in seg or not seg or not nss:
+                return seg
+            return f"{nss}:{seg}"
+
+        return "/".join([_process(seg) for seg in xpath.split("/")])
+
+    def xpath(self, xpath, nss=None):
+        """Namespace specific xpath searches
+
+        .. versionadded:: 1.1"""
+        return super().xpath(self.apply_nss(xpath, nss=nss), namespaces=NSS)
+
+    def find_one(self, name, nss=None):
+        """Return the first element matching the given name
+
+        .. versionadded:: 1.1"""
+        for elem in self.xpath(name, nss=nss):
+            return elem
+        return None
+
+    def get_text(self, name, default=None, nss=None):
+        """Get text content agnostically"""
+        for pref in ("", "_"):
+            elem = self.find_one(pref + name, nss=nss)
+            if elem is not None and elem.text:
+                if pref == "_":
+                    self.set_warning(f"Use of old translation scheme: <_{name}...>")
+                return elem.text
+        return default
+
+
+class ParamElement(InxElement):
+    """
+    A param in an inx file.
+    """
+
+    name = property(lambda self: self.get("name"))
+    param_type = property(lambda self: self.get("type", "string"))
+
+    @property
+    def options(self):
+        """Return a list of option values"""
+        if self.param_type == "notebook":
+            return [option.get("name") for option in self.xpath("page")]
+        return [option.get("value") for option in self.xpath("option")]
+
+    def __repr__(self):
+        return f"<param name='{self.name}' type='{self.param_type}'>"