bee_python 0.0.1

data/tools/logilab/logilab/common/ureports/docbook_writer.py

@@ -0,0 +1,139 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""HTML formatting drivers for ureports"""
+from __future__ import generators
+__docformat__ = "restructuredtext en"
+
+from logilab.common.ureports import HTMLWriter
+
+class DocbookWriter(HTMLWriter):
+    """format layouts as HTML"""
+
+    def begin_format(self, layout):
+        """begin to format a layout"""
+        super(HTMLWriter, self).begin_format(layout)
+        if self.snippet is None:
+            self.writeln('<?xml version="1.0" encoding="ISO-8859-1"?>')
+            self.writeln("""
+<book xmlns:xi='http://www.w3.org/2001/XInclude'
+      lang='fr'>
+""")
+
+    def end_format(self, layout):
+        """finished to format a layout"""
+        if self.snippet is None:
+            self.writeln('</book>')
+
+    def visit_section(self, layout):
+        """display a section (using <chapter> (level 0) or <section>)"""
+        if self.section == 0:
+            tag = "chapter"
+        else:
+            tag = "section"
+        self.section += 1
+        self.writeln(self._indent('<%s%s>' % (tag, self.handle_attrs(layout))))
+        self.format_children(layout)
+        self.writeln(self._indent('</%s>'% tag))
+        self.section -= 1
+
+    def visit_title(self, layout):
+        """display a title using <title>"""
+        self.write(self._indent('  <title%s>' % self.handle_attrs(layout)))
+        self.format_children(layout)
+        self.writeln('</title>')
+
+    def visit_table(self, layout):
+        """display a table as html"""
+        self.writeln(self._indent('  <table%s><title>%s</title>' \
+                     % (self.handle_attrs(layout), layout.title)))
+        self.writeln(self._indent('    <tgroup cols="%s">'% layout.cols))
+        for i in range(layout.cols):
+            self.writeln(self._indent('      <colspec colname="c%s" colwidth="1*"/>' % i))
+
+        table_content = self.get_table_content(layout)
+        # write headers
+        if layout.cheaders:
+            self.writeln(self._indent('      <thead>'))
+            self._write_row(table_content[0])
+            self.writeln(self._indent('      </thead>'))
+            table_content = table_content[1:]
+        elif layout.rcheaders:
+            self.writeln(self._indent('      <thead>'))
+            self._write_row(table_content[-1])
+            self.writeln(self._indent('      </thead>'))
+            table_content = table_content[:-1]
+        # write body
+        self.writeln(self._indent('      <tbody>'))
+        for i in range(len(table_content)):
+            row = table_content[i]
+            self.writeln(self._indent('        <row>'))
+            for j in range(len(row)):
+                cell = row[j] or '&#160;'
+                self.writeln(self._indent('          <entry>%s</entry>' % cell))
+            self.writeln(self._indent('        </row>'))
+        self.writeln(self._indent('      </tbody>'))
+        self.writeln(self._indent('    </tgroup>'))
+        self.writeln(self._indent('  </table>'))
+
+    def _write_row(self, row):
+        """write content of row (using <row> <entry>)"""
+        self.writeln('        <row>')
+        for j in range(len(row)):
+            cell = row[j] or '&#160;'
+            self.writeln('          <entry>%s</entry>' % cell)
+        self.writeln(self._indent('        </row>'))
+
+    def visit_list(self, layout):
+        """display a list (using <itemizedlist>)"""
+        self.writeln(self._indent('  <itemizedlist%s>' % self.handle_attrs(layout)))
+        for row in list(self.compute_content(layout)):
+            self.writeln('    <listitem><para>%s</para></listitem>' % row)
+        self.writeln(self._indent('  </itemizedlist>'))
+
+    def visit_paragraph(self, layout):
+        """display links (using <para>)"""
+        self.write(self._indent('  <para>'))
+        self.format_children(layout)
+        self.writeln('</para>')
+
+    def visit_span(self, layout):
+        """display links (using <p>)"""
+        #TODO: translate in docbook
+        self.write('<literal %s>' % self.handle_attrs(layout))
+        self.format_children(layout)
+        self.write('</literal>')
+
+    def visit_link(self, layout):
+        """display links (using <ulink>)"""
+        self.write('<ulink url="%s"%s>%s</ulink>' % (layout.url,
+                                               self.handle_attrs(layout),
+                                               layout.label))
+
+    def visit_verbatimtext(self, layout):
+        """display verbatim text (using <programlisting>)"""
+        self.writeln(self._indent('  <programlisting>'))
+        self.write(layout.data.replace('&', '&amp;').replace('<', '&lt;'))
+        self.writeln(self._indent('  </programlisting>'))
+
+    def visit_text(self, layout):
+        """add some text"""
+        self.write(layout.data.replace('&', '&amp;').replace('<', '&lt;'))
+
+    def _indent(self, string):
+        """correctly indent string according to section"""
+        return ' ' * 2*(self.section) + string

data/tools/logilab/logilab/common/ureports/html_writer.py

@@ -0,0 +1,131 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""HTML formatting drivers for ureports"""
+__docformat__ = "restructuredtext en"
+
+from cgi import escape
+
+from logilab.common.ureports import BaseWriter
+
+
+class HTMLWriter(BaseWriter):
+    """format layouts as HTML"""
+
+    def __init__(self, snippet=None):
+        super(HTMLWriter, self).__init__()
+        self.snippet = snippet
+
+    def handle_attrs(self, layout):
+        """get an attribute string from layout member attributes"""
+        attrs = ''
+        klass = getattr(layout, 'klass', None)
+        if klass:
+            attrs += ' class="%s"' % klass
+        nid = getattr(layout, 'id', None)
+        if nid:
+            attrs += ' id="%s"' % nid
+        return attrs
+
+    def begin_format(self, layout):
+        """begin to format a layout"""
+        super(HTMLWriter, self).begin_format(layout)
+        if self.snippet is None:
+            self.writeln('<html>')
+            self.writeln('<body>')
+
+    def end_format(self, layout):
+        """finished to format a layout"""
+        if self.snippet is None:
+            self.writeln('</body>')
+            self.writeln('</html>')
+
+
+    def visit_section(self, layout):
+        """display a section as html, using div + h[section level]"""
+        self.section += 1
+        self.writeln('<div%s>' % self.handle_attrs(layout))
+        self.format_children(layout)
+        self.writeln('</div>')
+        self.section -= 1
+
+    def visit_title(self, layout):
+        """display a title using <hX>"""
+        self.write('<h%s%s>' % (self.section, self.handle_attrs(layout)))
+        self.format_children(layout)
+        self.writeln('</h%s>' % self.section)
+
+    def visit_table(self, layout):
+        """display a table as html"""
+        self.writeln('<table%s>' % self.handle_attrs(layout))
+        table_content = self.get_table_content(layout)
+        for i in range(len(table_content)):
+            row = table_content[i]
+            if i == 0 and layout.rheaders:
+                self.writeln('<tr class="header">')
+            elif i+1 == len(table_content) and layout.rrheaders:
+                self.writeln('<tr class="header">')
+            else:
+                self.writeln('<tr class="%s">' % (i%2 and 'even' or 'odd'))
+            for j in range(len(row)):
+                cell = row[j] or '&#160;'
+                if (layout.rheaders and i == 0) or \
+                   (layout.cheaders and j == 0) or \
+                   (layout.rrheaders and i+1 == len(table_content)) or \
+                   (layout.rcheaders and j+1 == len(row)):
+                    self.writeln('<th>%s</th>' % cell)
+                else:
+                    self.writeln('<td>%s</td>' % cell)
+            self.writeln('</tr>')
+        self.writeln('</table>')
+
+    def visit_list(self, layout):
+        """display a list as html"""
+        self.writeln('<ul%s>' % self.handle_attrs(layout))
+        for row in list(self.compute_content(layout)):
+            self.writeln('<li>%s</li>' % row)
+        self.writeln('</ul>')
+
+    def visit_paragraph(self, layout):
+        """display links (using <p>)"""
+        self.write('<p>')
+        self.format_children(layout)
+        self.write('</p>')
+
+    def visit_span(self, layout):
+        """display links (using <p>)"""
+        self.write('<span%s>' % self.handle_attrs(layout))
+        self.format_children(layout)
+        self.write('</span>')
+
+    def visit_link(self, layout):
+        """display links (using <a>)"""
+        self.write(' <a href="%s"%s>%s</a>' % (layout.url,
+                                               self.handle_attrs(layout),
+                                               layout.label))
+    def visit_verbatimtext(self, layout):
+        """display verbatim text (using <pre>)"""
+        self.write('<pre>')
+        self.write(layout.data.replace('&', '&amp;').replace('<', '&lt;'))
+        self.write('</pre>')
+
+    def visit_text(self, layout):
+        """add some text"""
+        data = layout.data
+        if layout.escaped:
+            data = data.replace('&', '&amp;').replace('<', '&lt;')
+        self.write(data)

data/tools/logilab/logilab/common/ureports/nodes.py

@@ -0,0 +1,201 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""Micro reports objects.
+
+A micro report is a tree of layout and content objects.
+"""
+__docformat__ = "restructuredtext en"
+
+from logilab.common.tree import VNode
+
+class BaseComponent(VNode):
+    """base report component
+
+    attributes
+    * id : the component's optional id
+    * klass : the component's optional klass
+    """
+    def __init__(self, id=None, klass=None):
+        VNode.__init__(self, id)
+        self.klass = klass
+
+class BaseLayout(BaseComponent):
+    """base container node
+
+    attributes
+    * BaseComponent attributes
+    * children : components in this table (i.e. the table's cells)
+    """
+    def __init__(self, children=(), **kwargs):
+        super(BaseLayout, self).__init__(**kwargs)
+        for child in children:
+            if isinstance(child, BaseComponent):
+                self.append(child)
+            else:
+                self.add_text(child)
+
+    def append(self, child):
+        """overridden to detect problems easily"""
+        assert child not in self.parents()
+        VNode.append(self, child)
+
+    def parents(self):
+        """return the ancestor nodes"""
+        assert self.parent is not self
+        if self.parent is None:
+            return []
+        return [self.parent] + self.parent.parents()
+
+    def add_text(self, text):
+        """shortcut to add text data"""
+        self.children.append(Text(text))
+
+
+# non container nodes #########################################################
+
+class Text(BaseComponent):
+    """a text portion
+
+    attributes :
+    * BaseComponent attributes
+    * data : the text value as an encoded or unicode string
+    """
+    def __init__(self, data, escaped=True, **kwargs):
+        super(Text, self).__init__(**kwargs)
+        #if isinstance(data, unicode):
+        #    data = data.encode('ascii')
+        assert isinstance(data, (str, unicode)), data.__class__
+        self.escaped = escaped
+        self.data = data
+
+class VerbatimText(Text):
+    """a verbatim text, display the raw data
+
+    attributes :
+    * BaseComponent attributes
+    * data : the text value as an encoded or unicode string
+    """
+
+class Link(BaseComponent):
+    """a labelled link
+
+    attributes :
+    * BaseComponent attributes
+    * url : the link's target (REQUIRED)
+    * label : the link's label as a string (use the url by default)
+    """
+    def __init__(self, url, label=None, **kwargs):
+        super(Link, self).__init__(**kwargs)
+        assert url
+        self.url = url
+        self.label = label or url
+
+
+class Image(BaseComponent):
+    """an embedded or a single image
+
+    attributes :
+    * BaseComponent attributes
+    * filename : the image's filename (REQUIRED)
+    * stream : the stream object containing the image data (REQUIRED)
+    * title : the image's optional title
+    """
+    def __init__(self, filename, stream, title=None, **kwargs):
+        super(Link, self).__init__(**kwargs)
+        assert filename
+        assert stream
+        self.filename = filename
+        self.stream = stream
+        self.title = title
+
+
+# container nodes #############################################################
+
+class Section(BaseLayout):
+    """a section
+
+    attributes :
+    * BaseLayout attributes
+
+    a title may also be given to the constructor, it'll be added
+    as a first element
+    a description may also be given to the constructor, it'll be added
+    as a first paragraph
+    """
+    def __init__(self, title=None, description=None, **kwargs):
+        super(Section, self).__init__(**kwargs)
+        if description:
+            self.insert(0, Paragraph([Text(description)]))
+        if title:
+            self.insert(0, Title(children=(title,)))
+
+class Title(BaseLayout):
+    """a title
+
+    attributes :
+    * BaseLayout attributes
+
+    A title must not contains a section nor a paragraph!
+    """
+
+class Span(BaseLayout):
+    """a title
+
+    attributes :
+    * BaseLayout attributes
+
+    A span should only contains Text and Link nodes (in-line elements)
+    """
+
+class Paragraph(BaseLayout):
+    """a simple text paragraph
+
+    attributes :
+    * BaseLayout attributes
+
+    A paragraph must not contains a section !
+    """
+
+class Table(BaseLayout):
+    """some tabular data
+
+    attributes :
+    * BaseLayout attributes
+    * cols : the number of columns of the table (REQUIRED)
+    * rheaders : the first row's elements are table's header
+    * cheaders : the first col's elements are table's header
+    * title : the table's optional title
+    """
+    def __init__(self, cols, title=None,
+                 rheaders=0, cheaders=0, rrheaders=0, rcheaders=0,
+                 **kwargs):
+        super(Table, self).__init__(**kwargs)
+        assert isinstance(cols, int)
+        self.cols = cols
+        self.title = title
+        self.rheaders = rheaders
+        self.cheaders = cheaders
+        self.rrheaders = rrheaders
+        self.rcheaders = rcheaders
+
+class List(BaseLayout):
+    """some list data
+
+    attributes :
+    * BaseLayout attributes
+    """

data/tools/logilab/logilab/common/ureports/text_writer.py

@@ -0,0 +1,140 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""Text formatting drivers for ureports"""
+__docformat__ = "restructuredtext en"
+
+from logilab.common.textutils import linesep
+from logilab.common.ureports import BaseWriter
+
+
+TITLE_UNDERLINES = ['', '=', '-', '`', '.', '~', '^']
+BULLETS = ['*', '-']
+
+class TextWriter(BaseWriter):
+    """format layouts as text
+    (ReStructured inspiration but not totally handled yet)
+    """
+    def begin_format(self, layout):
+        super(TextWriter, self).begin_format(layout)
+        self.list_level = 0
+        self.pending_urls = []
+
+    def visit_section(self, layout):
+        """display a section as text
+        """
+        self.section += 1
+        self.writeln()
+        self.format_children(layout)
+        if self.pending_urls:
+            self.writeln()
+            for label, url in self.pending_urls:
+                self.writeln('.. _`%s`: %s' % (label, url))
+            self.pending_urls = []
+        self.section -= 1
+        self.writeln()
+
+    def visit_title(self, layout):
+        title = ''.join(list(self.compute_content(layout)))
+        self.writeln(title)
+        try:
+            self.writeln(TITLE_UNDERLINES[self.section] * len(title))
+        except IndexError:
+            print "FIXME TITLE TOO DEEP. TURNING TITLE INTO TEXT"
+
+    def visit_paragraph(self, layout):
+        """enter a paragraph"""
+        self.format_children(layout)
+        self.writeln()
+
+    def visit_span(self, layout):
+        """enter a span"""
+        self.format_children(layout)
+
+    def visit_table(self, layout):
+        """display a table as text"""
+        table_content = self.get_table_content(layout)
+        # get columns width
+        cols_width = [0]*len(table_content[0])
+        for row in table_content:
+            for index in range(len(row)):
+                col = row[index]
+                cols_width[index] = max(cols_width[index], len(col))
+        if layout.klass == 'field':
+            self.field_table(layout, table_content, cols_width)
+        else:
+            self.default_table(layout, table_content, cols_width)
+        self.writeln()
+
+    def default_table(self, layout, table_content, cols_width):
+        """format a table"""
+        cols_width = [size+1 for size in cols_width]
+        format_strings = ' '.join(['%%-%ss'] * len(cols_width))
+        format_strings = format_strings % tuple(cols_width)
+        format_strings = format_strings.split(' ')
+        table_linesep = '\n+' + '+'.join(['-'*w for w in cols_width]) + '+\n'
+        headsep = '\n+' + '+'.join(['='*w for w in cols_width]) + '+\n'
+        # FIXME: layout.cheaders
+        self.write(table_linesep)
+        for i in range(len(table_content)):
+            self.write('|')
+            line = table_content[i]
+            for j in range(len(line)):
+                self.write(format_strings[j] % line[j])
+                self.write('|')
+            if i == 0 and layout.rheaders:
+                self.write(headsep)
+            else:
+                self.write(table_linesep)
+
+    def field_table(self, layout, table_content, cols_width):
+        """special case for field table"""
+        assert layout.cols == 2
+        format_string = '%s%%-%ss: %%s' % (linesep, cols_width[0])
+        for field, value in table_content:
+            self.write(format_string % (field, value))
+
+
+    def visit_list(self, layout):
+        """display a list layout as text"""
+        bullet = BULLETS[self.list_level % len(BULLETS)]
+        indent = '  ' * self.list_level
+        self.list_level += 1
+        for child in layout.children:
+            self.write('%s%s%s ' % (linesep, indent, bullet))
+            child.accept(self)
+        self.list_level -= 1
+
+    def visit_link(self, layout):
+        """add a hyperlink"""
+        if layout.label != layout.url:
+            self.write('`%s`_' % layout.label)
+            self.pending_urls.append( (layout.label, layout.url) )
+        else:
+            self.write(layout.url)
+
+    def visit_verbatimtext(self, layout):
+        """display a verbatim layout as text (so difficult ;)
+        """
+        self.writeln('::\n')
+        for line in layout.data.splitlines():
+            self.writeln('    ' + line)
+        self.writeln()
+
+    def visit_text(self, layout):
+        """add some text"""
+        self.write(layout.data)