084a78483553f2f6cfed759bcce5b5efdfc85904
[extfs.d.git] / xml
1 #! /usr/bin/env python
2 """XML Virtual FileSystem for Midnight Commander
3
4 The script requires Midnight Commander 3.1+
5 (http://www.midnight-commander.org/), Python 2.4+ (http://www.python.org/).
6
7 For mc 4.7+ put the script in $HOME/[.local/share/].mc/extfs.d.
8 For older versions put it in /usr/[local/][lib|share]/mc/extfs
9 and add a line "xml" to the /usr/[local/][lib|share]/mc/extfs/extfs.ini.
10 Make the script executable.
11
12 For mc 4.7+ run this "cd" command in the Midnight Commander (in the "bindings"
13 file the command is "%cd"): cd file/xml://; In older versions it is
14 cd file#xml, where "file" is the name of your XML file.
15
16 The VFS represents tags as directories; the directories are numbered to
17 distinguish tags with the same name; also numbering helps to sort tags by their
18 order in XML instead of sorting them by name. Attributes, text nodes and
19 comments are represented as text files; attributes are shown in a file named
20 "attributes", attributes are listed in the file as name=value lines (I
21 deliberately ignore a small chance of newline characters in values); names and
22 values are reencoded to the console encoding. Text nodes and comments are
23 collected in a file named "text", stripped and reencoded. The filesystem is
24 read-only. ElementTree- and lxml.etree-based implementations don't show
25 namespaces as attributes.
26
27 It is useful to have a top-down view on an XML structure but it's especially
28 convenient to extract text values from tags. One can get, for example, a
29 base64-encoded image - just walk down the VFS to the tag's directory and copy
30 its text file to a real file.
31
32 The VFS was inspired by a FUSE xmlfs: https://github.com/halhen/xmlfs
33
34 """
35
36 __version__ = "0.5.0"
37 __author__ = "Oleg Broytman <phd@phdru.name>"
38 __copyright__ = "Copyright (C) 2013 PhiloSoft Design"
39 __license__ = "GPL"
40
41 default_implementation = None # Can be None for default choice,
42                               # 'lxml', 'elementtree' or 'minidom'
43
44 use_minidom = True
45 use_elementtree = False
46 use_lxml = False
47
48 import math
49 import sys
50 import xml.dom.minidom
51
52 try:
53     import xml.etree.ElementTree as ET
54 except ImportError:
55     pass
56 else:
57     use_elementtree = True
58
59 try:
60     import lxml.etree as etree
61 except ImportError:
62     pass
63 else:
64     use_lxml = True
65
66 try:
67    import locale
68    use_locale = True
69 except ImportError:
70    use_locale = False
71
72 if use_locale:
73    # Get the default charset.
74    try:
75       lcAll = locale.getdefaultlocale()
76    except locale.Error, err:
77       print >>sys.stderr, "WARNING:", err
78       lcAll = []
79
80    if len(lcAll) == 2:
81       default_encoding = lcAll[1]
82    else:
83       try:
84          default_encoding = locale.getpreferredencoding()
85       except locale.Error, err:
86          print >>sys.stderr, "WARNING:", err
87          default_encoding = sys.getdefaultencoding()
88 else:
89    default_encoding = sys.getdefaultencoding()
90
91 import logging
92 logger = logging.getLogger('xml-mcextfs')
93 log_err_handler = logging.StreamHandler(sys.stderr)
94 logger.addHandler(log_err_handler)
95 logger.setLevel(logging.INFO)
96
97 if len(sys.argv) < 3:
98     logger.critical("""\
99 XML Virtual FileSystem for Midnight Commander version %s
100 Author: %s
101 %s
102
103 This is not a program. Put the script in $HOME/[.local/share/].mc/extfs.d or
104 /usr/[local/][lib|share]/mc/extfs. For more information read the source!""",
105    __version__, __author__, __copyright__
106 )
107     sys.exit(1)
108
109
110 locale.setlocale(locale.LC_ALL, '')
111
112
113 class XmlVfs(object):
114     def __init__(self):
115         self.parse()
116
117     def list(self):
118         self._list(self.getroot())
119
120     def get_child_node(self, node, i):
121         n = 0
122         for element in self.getchildren(node):
123             if self.istag(element):
124                 n += 1
125                 if n == i:
126                     return element
127         xml_error('There are less than %d nodes' % i)
128
129
130 class MiniDOMXmlVfs(XmlVfs):
131     def parse(self):
132         self.document = xml.dom.minidom.parse(sys.argv[2])
133
134     def hasattrs(self, node):
135         return bool(node.attributes)
136
137     def attrs2text(self, node):
138         attrs = node.attributes
139         attrs = [attrs.item(i) for i in range (attrs.length)]
140         return '\n'.join(["%s=%s" %
141             (a.name.encode(default_encoding, "replace"),
142             a.value.encode(default_encoding, "replace"))
143             for a in attrs])
144
145     def collect_text(self, node):
146         text_accumulator = []
147         for element in node.childNodes:
148             if element.localName:
149                 continue
150             elif element.nodeType == element.COMMENT_NODE:
151                 text = u"<!--%s-->" % element.nodeValue
152             elif element.nodeType == element.TEXT_NODE:
153                 text = element.nodeValue.strip()
154             else:
155                 xml_error("Unknown node type %d" % element.nodeType)
156             if text: text_accumulator.append(text)
157         return '\n'.join(text_accumulator).encode(default_encoding, "replace")
158
159     def _list(self, node, path=''):
160         childNodes = node.childNodes
161         n = 0
162         for element in childNodes:
163             if element.localName:
164                 n += 1
165         if n:
166             width = int(math.log10(n))+1
167             template = "%%0%dd" % width
168         else:
169             template = "%d"
170         n = 0
171         for element in childNodes:
172             if element.localName:
173                 n += 1
174                 if path:
175                     subpath = '%s/%s %s' % (path, template % n, element.localName)
176                 else:
177                     subpath = '%s %s' % (template % n, element.localName)
178                 subpath_encoded = subpath.encode(default_encoding, "replace")
179                 print "dr-xr-xr-x 1 user group 0 Jan 1 00:00 %s" % subpath_encoded
180                 if self.hasattrs(element):
181                     attr_text = self.attrs2text(element)
182                     print "-r--r--r-- 1 user group %d Jan 1 00:00 %s/attributes" % (
183                         len(attr_text), subpath_encoded)
184                 text = self.collect_text(element)
185                 if text:
186                     print "-r--r--r-- 1 user group %d Jan 1 00:00 %s/text" % (
187                         len(text), subpath_encoded)
188                 self._list(element, subpath)
189
190     def getroot(self):
191         return self.document
192
193     def getchildren(self, node):
194         return node.childNodes
195
196     def istag(self, node):
197         return bool(node.localName)
198
199
200 if use_elementtree or use_lxml:
201     class CommonEtreeXmlVfs(XmlVfs):
202         def hasattrs(self, node):
203             return bool(node.attrib)
204
205         def collect_text(self, node):
206             text_accumulator = []
207             if node.text:
208                 text = node.text.strip()
209                 if text: text_accumulator.append(text)
210             for element in node:
211                 if not self.istag(element):
212                     text = u"<!--%s-->" % text
213                     text_accumulator.append(text)
214             if node.tail:
215                 text = node.tail.strip()
216                 if text: text_accumulator.append(text)
217             return '\n'.join(text_accumulator).encode(default_encoding, "replace")
218
219         def getroot(self):
220             return self.document.getroot()
221
222         def getchildren(self, node):
223             return list(node)
224
225         def istag(self, node):
226             return isinstance(node.tag, basestring)
227
228
229 if use_elementtree:
230     class ElementTreeXmlVfs(CommonEtreeXmlVfs):
231         def parse(self):
232             # Copied from http://effbot.org/zone/element-pi.ht
233
234             class PIParser(ET.XMLTreeBuilder):
235
236                def __init__(self):
237                    ET.XMLTreeBuilder.__init__(self)
238                    # assumes ElementTree 1.2.X
239                    self._parser.CommentHandler = self.handle_comment
240                    self._parser.ProcessingInstructionHandler = self.handle_pi
241                    self._target.start("document", {})
242
243                def close(self):
244                    self._target.end("document")
245                    return ET.XMLTreeBuilder.close(self)
246
247                def handle_comment(self, data):
248                    self._target.start(ET.Comment, {})
249                    self._target.data(data)
250                    self._target.end(ET.Comment)
251
252                def handle_pi(self, target, data):
253                    self._target.start(ET.PI, {})
254                    self._target.data(target + " " + data)
255                    self._target.end(ET.PI)
256
257             self.document = ET.parse(sys.argv[2], PIParser())
258
259         def attrs2text(self, node):
260             attr_accumulator = []
261             for name, value in node.attrib.items():
262                 name = name.encode(default_encoding, "replace")
263                 value = value.encode(default_encoding, "replace")
264                 if name.startswith('{'):
265                     name = name.split('}', 1)[1] # Remove XML namespace
266                 attr_accumulator.append("%s=%s" % (name, value))
267             return '\n'.join(attr_accumulator)
268
269         def _list(self, node, path=''):
270             n = len(node)
271             if n:
272                 width = int(math.log10(n))+1
273                 template = "%%0%dd" % width
274             else:
275                 template = "%d"
276             n = 0
277             for element in node:
278                 if not isinstance(element.tag, basestring):
279                     continue
280                 n += 1
281                 tag = element.tag
282                 if tag.startswith('{'):
283                     tag = tag.split('}', 1)[1] # Remove XML namespace
284                 if path:
285                     subpath = '%s/%s %s' % (path, template % n, tag)
286                 else:
287                     subpath = '%s %s' % (template % n, tag)
288                 subpath_encoded = subpath.encode(default_encoding, "replace")
289                 print "dr-xr-xr-x 1 user group 0 Jan 1 00:00 %s" % subpath_encoded
290                 if self.hasattrs(element):
291                     attr_text = self.attrs2text(element)
292                     print "-r--r--r-- 1 user group %d Jan 1 00:00 %s/attributes" % (
293                         len(attr_text), subpath_encoded)
294                 text = self.collect_text(element)
295                 if text:
296                     print "-r--r--r-- 1 user group %d Jan 1 00:00 %s/text" % (
297                         len(text), subpath_encoded)
298                 self._list(element, subpath)
299
300
301 if use_lxml:
302     class LxmlEtreeXmlVfs(CommonEtreeXmlVfs):
303         def parse(self):
304             self.document = etree.parse(sys.argv[2])
305
306         def attrs2text(self, node):
307             attr_accumulator = []
308             for name, value in node.attrib.items():
309                 name = etree.QName(name).localname.encode(default_encoding, "replace")
310                 value = value.encode(default_encoding, "replace")
311                 attr_accumulator.append("%s=%s" % (name, value))
312             return '\n'.join(attr_accumulator)
313
314         def list(self):
315             self._list(self.getroot())
316
317         def _list(self, node, path=''):
318             n = len(node)
319             if n:
320                 width = int(math.log10(n))+1
321                 template = "%%0%dd" % width
322             else:
323                 template = "%d"
324             n = 0
325             for element in node:
326                 if not isinstance(element.tag, basestring):
327                     continue
328                 n += 1
329                 tag = etree.QName(element.tag).localname
330                 if path:
331                     subpath = '%s/%s %s' % (path, template % n, tag)
332                 else:
333                     subpath = '%s %s' % (template % n, tag)
334                 subpath_encoded = subpath.encode(default_encoding, "replace")
335                 print "dr-xr-xr-x 1 user group 0 Jan 1 00:00 %s" % subpath_encoded
336                 if self.hasattrs(element):
337                     attr_text = self.attrs2text(element)
338                     print "-r--r--r-- 1 user group %d Jan 1 00:00 %s/attributes" % (
339                         len(attr_text), subpath_encoded)
340                 text = self.collect_text(element)
341                 if text:
342                     print "-r--r--r-- 1 user group %d Jan 1 00:00 %s/text" % (
343                         len(text), subpath_encoded)
344                 self._list(element, subpath)
345
346         def getroot(self):
347             return [self.document.getroot()]
348
349
350 def build_xmlvfs():
351     if default_implementation is None:
352         if use_lxml:
353             return LxmlEtreeXmlVfs()
354         elif use_elementtree:
355             return ElementTreeXmlVfs()
356         else:
357             return MiniDOMXmlVfs()
358     elif default_implementation == 'minidom':
359         return MiniDOMXmlVfs()
360     elif default_implementation == 'elementtree':
361         return ElementTreeXmlVfs()
362     elif default_implementation == 'lxml':
363         return LxmlEtreeXmlVfs()
364
365
366 def mcxml_list():
367     """List the entire VFS"""
368
369     xmlvfs = build_xmlvfs()
370     xmlvfs.list()
371
372
373 def mcxml_copyout():
374     """Extract a file from the VFS"""
375
376     xmlvfs = build_xmlvfs()
377     xml_filename = sys.argv[3]
378     real_filename = sys.argv[4]
379
380     node = xmlvfs.getroot()
381     for path_comp in xml_filename.split('/'):
382         if ' ' in path_comp:
383             i = int(path_comp.split(' ', 1)[0])
384             node = xmlvfs.get_child_node(node, i)
385         elif path_comp in ('attributes', 'text'):
386             break
387         else:
388             xml_error('Unknown file')
389
390     if path_comp == 'attributes':
391         if xmlvfs.hasattrs(node):
392             text = xmlvfs.attrs2text(node)
393         else:
394             xml_error('There are no attributes')
395
396     if path_comp == 'text':
397         text = xmlvfs.collect_text(node)
398
399     outfile = open(real_filename, 'w')
400     outfile.write(text)
401     outfile.close()
402
403
404 def mcxml_copyin():
405     """Put a file to the VFS"""
406     sys.exit("XML VFS doesn't support adding files (read-only filesystem)")
407
408 def mcxml_rm():
409     """Remove a file from the VFS"""
410     sys.exit("XML VFS doesn't support removing files/directories (read-only filesystem)")
411
412 mcxml_rmdir = mcxml_rm
413
414 def mcxml_mkdir():
415     """Create a directory in the VFS"""
416     sys.exit("XML VFS doesn't support creating directories (read-only filesystem)")
417
418
419 def xml_error(error_str):
420     logger.critical("Error walking XML file: %s", error_str)
421     sys.exit(1)
422
423 command = sys.argv[1]
424 procname = "mcxml_" + command
425
426 g = globals()
427 if not g.has_key(procname):
428     logger.critical("Unknown command %s", command)
429     sys.exit(1)
430
431 try:
432     g[procname]()
433 except SystemExit:
434     raise
435 except:
436     logger.exception("Error during run")