root/converter.py

# Copyright (C) 2007, Stefan Schwarzer
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

"""
Convert data to HTML representations.
"""

import cgi
import os
import urllib
import sys

# Websourcebrowser modules
import coding
import config
import dirtree
import pygmentsfinder
import session
import tools
import urlpath


def _dir_options_to_html(path, params):
    """
    Return the menu of options preceding the directory display.
    """
    html_parts = []
    add_html = html_parts.append
    # show horizontal menu of directory levels
    add_html('<p class="Options">')
    add_html('<a href="/" target="_top">Reset view</a>')
    add_html('&nbsp;')
    add_html('<a href="%s" target="_blank">Homepage</a>' %
             cgi.escape(config.project_homepage))
#     add_html('&nbsp;')
#     add_html('<a href="/%s/help" target="%s">Help</a>' %
#              (config.SPECIAL_DIR, config.HELP_WINDOW_TARGET))
    add_html('</p>')
    add_html('<p class="Options">')
    add_html('Directory levels: ')
    dir_levels = params['dir_levels']
    # 1 should always be there
    level_options = [(1, "1")]
    # `dir_levels - 1`
    numeric_value = dir_levels - 1
    numeric_value = max(numeric_value, 1)
    value = str(numeric_value)
    level_options.append((numeric_value, value))
    # `dir_levels`
    numeric_value = dir_levels
    value = str(numeric_value)
    level_options.append((numeric_value, value))
    # `dir_levels + 1`
    numeric_value = dir_levels + 1
    numeric_value = min(numeric_value, sys.maxint)
    value = str(numeric_value)
    level_options.append((numeric_value, value))
    # all
    numeric_value = sys.maxint
    value = "all"
    level_options.append((numeric_value, value))
    # sort offered dir levels
    level_options.sort()
    # remove duplicates
    found_numeric_values = []
    new_level_options = []
    for numeric_value, value in level_options:
        # check if we had this integer already; skip if yes
        if numeric_value in found_numeric_values:
            continue
        # it doesn't make sense to have huge numeric values except the maximum
        if numeric_value > 100 and numeric_value != sys.maxint:
            continue
        if numeric_value == sys.maxint:
            value = "all"
        found_numeric_values.append(numeric_value)
        new_level_options.append((numeric_value, value))
    # build menu
    for numeric_value, value in new_level_options:
        if numeric_value == dir_levels:
            add_html(u'%s&nbsp;' % value)
        else:
            url = urlpath.to_url(config.root, path)
            new_params = params.copy()
            new_params['dir_levels'] = numeric_value
            url = session.default_session.add_to_url(url, new_params)
            add_html(u'<a href="%s">%s</a>&nbsp;' % (cgi.escape(url), value))
    add_html('</p>')
    return "\n".join(html_parts)

def dir_to_html(path, params):
    """
    Return HTML code unicode string for the directory `path`.
    """
    path = os.path.normpath(path)
    start_level = dirtree.dir_level(path)
    tree = dirtree.DirectoryTree(path)
    tree.read(depth=params['dir_levels'])
    if tree.items:
        actual_dir_levels = max([dirtree.dir_level(item)
                                 for item in tree.items]) \
                            - start_level
    else:
        actual_dir_levels = 1
    params['dir_levels'] = actual_dir_levels
    html_parts = []
    add_html = html_parts.append
    add_html(_dir_options_to_html(path, params))
    # show directory listing
    add_html(u'<table>')
    if path != config.root:
        parent_url = urlpath.to_url(config.root, path) + "/.."
        params['frames'] = "yes"
        parent_url = session.default_session.add_to_url(parent_url, params)
        add_html(u'<tr><td class="Options">'
          u'<a href="%s" target="_top">up</a></td></tr>' % parent_url)
    for item in tree.items:
        # HTML for spacing
        spacing = (u'<span class="Indent">' +
                   # something like ">   " times ...
                   (u'&gt;' + (config.dir_indent-1) * u'&nbsp;') * \
                   # ... the nesting level
                   (dirtree.dir_level(item) - start_level - 1) +
                   u'</span>')
        # HTML for link or plain text if the path isn't readable
        link_text = cgi.escape(coding.decode(os.path.basename(item)))
        if os.access(item, os.R_OK):
            if os.path.isdir(item):
                anchor = tools.url_to_anchor(urlpath.to_url(config.root, item))
                # mask characters problematic for anchors
                params['anchor'] = anchor
                params['frames'] = "yes"
                params['dir_levels'] = \
                  max(actual_dir_levels,
                      dirtree.dir_level(item) - start_level + 1)
                url = urlpath.to_url(config.root, path)
                url = session.default_session.add_to_url(url, params)
                target = "_top"
            else:
                # delete `anchor` and `dir_levels` items
                params.pop('anchor', None)
                params.pop('dir_levels', None)
                params['frames'] = "no"
                url = urlpath.to_url(config.root, item)
                url = session.default_session.add_to_url(url, params)
                target = config.SOURCE_WINDOW_TARGET
            title = cgi.escape(coding.decode(
                    urllib.unquote(urlpath.to_url(config.root, item))))
            link = u'<a href="%s" title="%s" target="%s">%s</a>' % \
                   (cgi.escape(url), title, target, link_text)
            # add an anchor in order to jump to directories
            if os.path.isdir(item):
                link = u'<a name="%s"></a>%s' % (anchor, link)
        else:
            # not really a link
            link = link_text
        # HTML for suffix
        if os.path.isdir(item):
            params.pop('anchor')
            new_root_url = session.default_session.add_to_url(
                           urlpath.to_url(config.root, item), params)
            suffix = (u'&nbsp;/&nbsp;&nbsp;<small>'
                      u'<a href="%s" target="_top">'
                      u'set&nbsp;view</a></small>') % new_root_url
        else:
            suffix = ""
        add_html(u'<tr><td>%s%s%s</td></tr>' % (spacing, link, suffix))
    add_html(u'</table>')
    return u"\n".join(html_parts)

def dumb_text_to_html(text):
    """
    Return an HTML representation of the `text`. The part "dumb"
    in the name of the method means that the method does the
    minimally necessary work.
    """
    return u"\n".join(('<pre>', cgi.escape(text), '</pre>'))

def text_to_html(text, path):
    """
    Convert the unicode string `text` to HTML and return the HTML
    code, also as unicode string. Use the `path` of a text file to
    guess the MIME type, which is used for coloring source code.
    """
    if not pygmentsfinder.found_pygments:
        return dumb_text_to_html(text)
    try:
        # assume the link doesn't point to a link or at least has
        #  a sensible name
        if os.path.islink(path):
            path = os.path.abspath(os.readlink(path))
        lexer = pygmentsfinder.lexers.guess_lexer_for_filename(path, text)
    except pygmentsfinder.lexers.ClassNotFound:
        # files with many extensions are actually XML files, so
        #  test explicitly for them
        if text.lstrip().startswith(u'<?xml '):
            lexer = pygmentsfinder.lexers.XmlLexer()
        else:
            lexer = pygmentsfinder.lexers.TextLexer()
    formatter = pygmentsfinder.formatters.HtmlFormatter(
                linenos=config.line_numbers)
    html = pygmentsfinder.pygments.highlight(text, lexer, formatter)
    return html

def image_to_html(url):
    """
    Return HTML code (as unicode) for an image link for an image
    which can be found under the absolute `url`.
    """
    image_source = "/%s/raw_data?url=%s" % (config.SPECIAL_DIR, url)
    return u'<img src="%s" />' % image_source

def binary_to_html(data):
    """
    Return HTML code (as unicode) for supposed binary `data` in
    form of a hex dump. The `data` must have been read in binary
    mode.
    """
    # based on
    #  http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/142812
    filter_ = ''.join(
      [(len(repr(chr(x)))==3) and chr(x) or '.' for x in range(256)])
    length = 16
    result = []
    for i in xrange(0, len(data), length):
        s = data[i:i+length]
        hexa = ' '.join(["%02X" % ord(x) for x in s])
        if len(s) > length // 2:
            hexa = "%s %s" % (hexa[:23], hexa[23:])
        printable = s.translate(filter_)
        result.append("%08X    %-*s    |%s|\n" % (i, length*3, hexa,
                                                  printable))
    return dumb_text_to_html(''.join(result))