RubyGems - deplate - Versions diffs - 0.7.3 - Mend

deplate 0.7.3

Files changed (145) hide show

data/AUTHORS.TXT +26 -0
data/CHANGES.TXT +177 -0
data/LICENSE.TXT +340 -0
data/NEWS.TXT +29 -0
data/README.TXT +86 -0
data/TODO.TXT +202 -0
data/VERSION.TXT +1 -0
data/bin/deplate +3 -0
data/bin/deplate.bat +2 -0
data/etc/deplate.ini +361 -0
data/lib/deplate.rb +31 -0
data/lib/deplate/abstract-class.rb +30 -0
data/lib/deplate/builtin.rb +11 -0
data/lib/deplate/cache.rb +59 -0
data/lib/deplate/commands.rb +693 -0
data/lib/deplate/common.rb +335 -0
data/lib/deplate/converter.rb +99 -0
data/lib/deplate/core.rb +2705 -0
data/lib/deplate/css/article.css +545 -0
data/lib/deplate/css/deplate.css +699 -0
data/lib/deplate/css/heading-navbar.css +29 -0
data/lib/deplate/css/layout-deplate-print.css +540 -0
data/lib/deplate/css/layout-deplate.css +764 -0
data/lib/deplate/css/sans-serif.css +160 -0
data/lib/deplate/css/serif-e.css +170 -0
data/lib/deplate/css/serif-rel.css +121 -0
data/lib/deplate/css/serif.css +190 -0
data/lib/deplate/css/slides.css +11 -0
data/lib/deplate/css/tabbar-left.css +91 -0
data/lib/deplate/css/tabbar-right-ie.css +14 -0
data/lib/deplate/css/tabbar-right.css +118 -0
data/lib/deplate/css/tabbar-top.css +64 -0
data/lib/deplate/css/tabbar.css +81 -0
data/lib/deplate/css/text-sans-serif.css +154 -0
data/lib/deplate/css/text-serif.css +175 -0
data/lib/deplate/define.rb +439 -0
data/lib/deplate/docbook.rb +738 -0
data/lib/deplate/elements.rb +1355 -0
data/lib/deplate/etc.rb +199 -0
data/lib/deplate/external.rb +135 -0
data/lib/deplate/fmt/dbk-article-4.1.2.rb +21 -0
data/lib/deplate/fmt/dbk-article.rb +46 -0
data/lib/deplate/fmt/dbk-book.rb +46 -0
data/lib/deplate/fmt/dbk-ref.rb +105 -0
data/lib/deplate/fmt/dbk-slides.rb +47 -0
data/lib/deplate/fmt/dbk-snippet.rb +21 -0
data/lib/deplate/fmt/html-snippet.rb +21 -0
data/lib/deplate/fmt/html.rb +1696 -0
data/lib/deplate/fmt/htmlsite.rb +419 -0
data/lib/deplate/fmt/htmlslides.rb +21 -0
data/lib/deplate/fmt/htmlwebsite.rb +70 -0
data/lib/deplate/fmt/latex-snippet.rb +22 -0
data/lib/deplate/fmt/latex.rb +1242 -0
data/lib/deplate/fmt/php.rb +19 -0
data/lib/deplate/fmt/phpsite.rb +19 -0
data/lib/deplate/fmt/plain.rb +598 -0
data/lib/deplate/fmt/template.rb +34 -0
data/lib/deplate/fmt/xhtml10t.rb +41 -0
data/lib/deplate/formatter-snippet.rb +17 -0
data/lib/deplate/formatter.rb +1210 -0
data/lib/deplate/input.rb +492 -0
data/lib/deplate/input/deplate-headings.rb +48 -0
data/lib/deplate/input/deplate-restricted.rb +70 -0
data/lib/deplate/input/deplate.rb +28 -0
data/lib/deplate/input/rdoc.rb +277 -0
data/lib/deplate/input/template.rb +29 -0
data/lib/deplate/lib/latex/highlight-extra.sty +15 -0
data/lib/deplate/lib/latex/highlight-typical.sty +15 -0
data/lib/deplate/lib/tabmenu.js +146 -0
data/lib/deplate/locale/de.latin1 +708 -0
data/lib/deplate/locale/ru.koi8-r +48 -0
data/lib/deplate/locale/zh_cn.gb2312 +35 -0
data/lib/deplate/macros.rb +639 -0
data/lib/deplate/messages.rb +120 -0
data/lib/deplate/metadata.rb +77 -0
data/lib/deplate/metadata/marshal.rb +24 -0
data/lib/deplate/metadata/xml.rb +42 -0
data/lib/deplate/metadata/yaml.rb +26 -0
data/lib/deplate/mod/anyword.rb +56 -0
data/lib/deplate/mod/babelfish.rb +27 -0
data/lib/deplate/mod/code-gvim.rb +52 -0
data/lib/deplate/mod/code-highlight.rb +91 -0
data/lib/deplate/mod/colored-log.rb +17 -0
data/lib/deplate/mod/de.rb +19 -0
data/lib/deplate/mod/en.rb +17 -0
data/lib/deplate/mod/endnotes.rb +60 -0
data/lib/deplate/mod/fr.rb +46 -0
data/lib/deplate/mod/html-asciimath.rb +40 -0
data/lib/deplate/mod/html-deplate-button.rb +15 -0
data/lib/deplate/mod/html-headings-navbar.rb +39 -0
data/lib/deplate/mod/html-obfuscate-email.rb +47 -0
data/lib/deplate/mod/html-sidebar.rb +232 -0
data/lib/deplate/mod/htmlslides-navbar-fh.rb +32 -0
data/lib/deplate/mod/iconv.rb +35 -0
data/lib/deplate/mod/imgurl.rb +30 -0
data/lib/deplate/mod/inlatex-compound.rb +69 -0
data/lib/deplate/mod/koma.rb +109 -0
data/lib/deplate/mod/latex-emph-table-head.rb +38 -0
data/lib/deplate/mod/latex-styles.rb +461 -0
data/lib/deplate/mod/latex-verbatim-small.rb +29 -0
data/lib/deplate/mod/makefile.rb +194 -0
data/lib/deplate/mod/mark-external-urls.rb +38 -0
data/lib/deplate/mod/markup-1-warn.rb +37 -0
data/lib/deplate/mod/markup-1.rb +41 -0
data/lib/deplate/mod/navbar-png.rb +33 -0
data/lib/deplate/mod/noindent.rb +32 -0
data/lib/deplate/mod/numpara.rb +40 -0
data/lib/deplate/mod/particle-math.rb +34 -0
data/lib/deplate/mod/php-extra.rb +44 -0
data/lib/deplate/mod/pstoedit.rb +71 -0
data/lib/deplate/mod/recode.rb +57 -0
data/lib/deplate/mod/ru_koi8-r.rb +20 -0
data/lib/deplate/mod/smiley.rb +50 -0
data/lib/deplate/mod/soffice.rb +23 -0
data/lib/deplate/mod/symbols-latin1.rb +58 -0
data/lib/deplate/mod/symbols-od-utf-8.rb +16 -0
data/lib/deplate/mod/symbols-plain.rb +58 -0
data/lib/deplate/mod/symbols-sgml.rb +97 -0
data/lib/deplate/mod/symbols-utf-8.rb +81 -0
data/lib/deplate/mod/symbols-xml.rb +34 -0
data/lib/deplate/mod/syntax-region-alt.rb +37 -0
data/lib/deplate/mod/utf8.rb +49 -0
data/lib/deplate/mod/validate-html.rb +35 -0
data/lib/deplate/mod/xmlrpc.rb +233 -0
data/lib/deplate/mod/zh-cn-autospace.rb +108 -0
data/lib/deplate/mod/zh-cn.rb +59 -0
data/lib/deplate/once-method.rb +44 -0
data/lib/deplate/output.rb +249 -0
data/lib/deplate/particles.rb +815 -0
data/lib/deplate/regions.rb +1076 -0
data/lib/deplate/structured.rb +763 -0
data/lib/deplate/template.rb +430 -0
data/lib/deplate/templates/html-doc.html +28 -0
data/lib/deplate/templates/html-left-tabbar-js.html +37 -0
data/lib/deplate/templates/html-left-tabbar.html +31 -0
data/lib/deplate/templates/html-tabbar-right-table.html +43 -0
data/lib/deplate/templates/html-tabbar-right.html +23 -0
data/lib/deplate/templates/html-tabbar-top.html +43 -0
data/lib/deplate/templates/html-tabbar.html +31 -0
data/lib/deplate/wiki-markup.rb +117 -0
data/lib/deplate/xml.rb +109 -0
data/lib/deplate/zh-cn.rb +59 -0
data/lib/ps2ppm.rb +239 -0
data/man/man1/deplate.1 +692 -0
metadata +210 -0

data/lib/deplate/fmt/template.rb ADDED Viewed

@@ -0,0 +1,34 @@
+# template.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     25-M�r-2005.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.21
+#
+# = Description
+# The formatter for templates
+# A pseudo-formatter used for templates.
+class Deplate::Formatter::Template < Deplate::Formatter
+    self.myname = "template"
+    self.rx     = /template/i
+    self.suffix = ".out"
+    self.label_mode     = :delegate
+    self.label_delegate = []
+    self.label_once     = []
+    def plain_text(text, escaped=false)
+        return text
+    end
+    def format_unknown(invoker)
+        invoker.elt
+    end
+    def format_paragraph(invoker)
+        invoker.elt
+    end
+end

data/lib/deplate/fmt/xhtml10t.rb ADDED Viewed

@@ -0,0 +1,41 @@
+# fmt-xhtml.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     03-Aug-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.35
+require "deplate/fmt/html"
+class Deplate::Formatter::XHTML10transitional <  Deplate::Formatter::HTML
+    self.myname   = "xhtml10t"
+    self.rx     = /x?html?/i
+    self.suffix = ".xhtml"
+    def head_doctype
+        return %Q{<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+            "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">}
+    end
+    def html_lang(stripped=false)
+    end
+    def html_def
+        acc = [%{xmlns="http://www.w3.org/1999/xhtml"}]
+        lang = @deplate.options.messages.prop('lang', self)
+        if lang
+            acc << %{lang="#{lang}"} << %{xml:lang="#{lang}"}
+        end
+        "<html #{acc.join(" ")}>"
+    end
+    def head_meta_tag(text)
+        return %Q{<meta #{text} />}
+    end
+    def head_link_tag(text)
+        return %Q{<link #{text} />}
+    end
+end

data/lib/deplate/formatter-snippet.rb ADDED Viewed

@@ -0,0 +1,17 @@
+# formatter-snippet.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     11-Aug-2005.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.3
+module Deplate::Snippet
+    def formatter_initialize_snippet
+        unless @deplate.options.included
+            log(['Not run in included mode'], :error)
+            log(['Set included mode'], :error)
+            @deplate.options.included = true
+        end
+    end
+end

data/lib/deplate/formatter.rb ADDED Viewed

@@ -0,0 +1,1210 @@
+# formatter.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     31-Okt-2004.
+# @Last Change: 02-Nov-2005.
+# @Revision:    0.923
+require "deplate/abstract-class"
+# Description:
+# An abstract formatter class
+#
+# Usage:
+#
+# TODO:
+#
+# CHANGES:
+#
+class Deplate::Formatter
+    class << self
+        def noop(context, name)
+            context.module_eval %{
+                def #{name}(*args)
+                    return ""
+                end
+            }
+        end
+        attr_writer :suffix, :myname, :rx, :label_mode, :label_delegate, :label_once
+        def get_class_attrib(name, default=nil)
+            if self == Deplate::Formatter
+                return default
+            end
+            iv = "@#{name}"
+            if self.instance_variables.include?(iv)
+                val = self.instance_variable_get(iv)
+                if val
+                    return val
+                end
+            end
+            return self.superclass.get_class_attrib(name, default)
+        end
+        def suffix
+            get_class_attrib('suffix')
+        end
+        def myname
+            get_class_attrib('myname')
+        end
+        def myname=(name)
+            @myname = name
+            klass   = self
+            Deplate::Core.class_eval {declare_formatter(klass)}
+        end
+        def rx
+            get_class_attrib('rx')
+        end
+        def label_mode
+            get_class_attrib('label_mode', :enclose)
+        end
+        def label_delegate
+            get_class_attrib('label_delegate', [])
+        end
+        def label_once
+            get_class_attrib('label_once', [])
+        end
+    end
+    @@custom_particles = {}
+    attr_reader :deplate
+    attr_reader :advices
+    attr_accessor :special_symbols
+    def initialize(deplate, args={})
+        @deplate     = deplate
+        @variables   = deplate.variables
+        @bibentries  = {}
+        @open_labels = []
+        @advices     = args[:advices] || {}
+        @inlatex_idx = 0
+        @encodings   = {}
+        @consumed_labels = []
+        @consumed_ids    = []
+    end
+    def retrieve_particle(id, body=nil, specific=false)
+        fmt       = specific ? formatter_name : '_'
+        particles = @@custom_particles[fmt] ||= {}
+        particle  = particles[id]
+        if particle
+            if body.nil? or particle[:body] == body
+                return particle[:class]
+            end
+        end
+        return nil
+    end
+    def store_particle(id, body, particle, specific=false)
+        fmt           = specific ? formatter_name : '_'
+        particles     = @@custom_particles[fmt] ||= {}
+        particles[id] = {:body => body, :class => particle}
+    end
+    def def_advice(applicant, agent, args)
+        this = @advices[agent] ||= {}
+        for type in [:wrap]
+            thistype = []
+            prc = args[type]
+            if prc
+                if prc.kind_of?(Proc)
+                    thistype << {:applicant => applicant, :prc => prc}
+                else
+                    raise "Not a Proc: %s" % prc
+                end
+            end
+            unless thistype.empty?
+                if this[type]
+                    this[type] += thistype
+                else
+                    this[type] = thistype
+                end
+            end
+        end
+        for type in [:before, :around, :after]
+            prc = args[type]
+            if prc
+                log(["Unsupported advice type", type, applicant, prc], :error)
+            end
+        end
+    end
+    def log(*args)
+        Deplate::Core.log(*args)
+    end
+    def canonic_enc_name(enc, table=@encodings)
+        case enc.downcase
+        when 'latin-1', 'latin1', 'l1', 'isolat1', 'iso-8859-1'
+            cen = 'latin1'
+        when 'latin-9', 'latin9', 'l9', 'isolat9', 'iso-8859-15'
+            cen = 'latin9'
+        when 'gb2312', 'gbk'
+            cen = 'gb2312'
+        when 'koi8-r'
+            cen = 'koi8-r'
+        when 'utf8', 'utf-8'
+            cen = 'utf-8'
+        else
+            log(['Unsupported encoding', enc], :anyway)
+            cen = enc
+        end
+        return table[cen] || cen
+    end
+    def join_blocks(blocks)
+        blocks.flatten.compact.join("\n")
+    end
+    def join_inline(strings)
+        strings.flatten.compact.join
+    end
+    def format_particle(agent, invoker, *args)
+        # rv = with_agent(agent, Array, invoker, *args)
+        # rv.empty? ? format_unknown_particle(invoker) : rv.join
+        with_agent(agent, Array, invoker, *args)
+    end
+    def format_particle_as_string(agent, object, *args)
+        join_inline(format_particle(agent, object, *args))
+    end
+    def format_element(agent, invoker, *args)
+        # rv = with_agent(agent, Array, invoker, *args)
+        # rv.empty? ? format_unknown(invoker) : join_blocks(rv)
+        with_agent(agent, Array, invoker, *args)
+    end
+    def format_element_as_string(agent, object, *args)
+        format_element(agent, object, *args)
+    end
+    def with_agent(agent, prototype, invoker, *args)
+        log(["Call with agent", agent, invoker.class, args], :debug)
+        if respond_to?(agent)
+            before  = []
+            inner   = nil
+            after   = []
+            stylish = @advices[agent]
+            if stylish
+                # pre = stylish[:before]
+                # if pre
+                    # for advice in pre
+                        # before << advice[:prc].call(invoker, *args)
+                    # end
+                # end
+                inner = self.send(agent, invoker, *args)
+                prototype ||= inner.class
+                around = stylish[:wrap]
+                if around
+                    inner =  around.inject(inner) do |acc, advice|
+                        advice[:prc].call(agent, acc, invoker, *args)
+                    end
+                end
+                # post  = stylish[:after]
+                # if post
+                    # for advice in post
+                        # after << advice[:prc].call(invoker, *args)
+                    # end
+                # end
+            else
+                args  = args.unshift(invoker)
+                begin
+                    inner = self.send(agent, *args)
+                rescue Exception => e
+                    puts "DBG: #{agent}"
+                    puts e.backtrace[0..10].join("\n")
+                    raise e
+                end
+                prototype ||= inner.class
+            end
+            # if prototype == String
+                # rv = [before, inner, after].join
+            # elsif prototype == Integer
+                # rv = [before, inner, after].join.to_i
+            # elsif inner.kind_of?(Array)
+                # rv = before + inner + after
+            # else
+                # rv = before + [inner] + after
+            # end
+            # return rv
+            return inner
+        else
+            invoker.log(["Unknown formatting agent", agent], :error)
+            return nil
+        end
+    end
+    def output(invoker, *body)
+        output_at(invoker.doc_type, invoker.doc_slot, *body)
+    end
+    def output_preferably_at(invoker, type, slot, *body)
+        type = defined?(invoker.doc_type) ? invoker.doc_type(type) : type
+        slot = defined?(invoker.doc_slot) ? invoker.doc_slot(slot) : slot
+        output_at(type, slot, *body)
+    end
+    def output_empty_at?(type, slot)
+        @deplate.output.empty_at?(type, slot)
+    end
+    # def_delegator(:@deplate, :add_at, :output_at)
+    def output_at(type, slot, *body)
+        log(["Output at", "#{type}@#{slot}", body], :debug)
+        @deplate.output.add_at(type, slot, *body)
+    end
+    # def_delegator(:@deplate, :union_at)
+    def union_at(type, slot, *body)
+        @deplate.output.union_at(type, slot, *body)
+    end
+    # def_delegator(:@deplate, :set_at)
+    def set_at(type, slot, *body)
+        @deplate.output.set_at(type, slot, *body)
+    end
+    # push *options to variables['classOptions']
+    def push_class_option(*options)
+        acc = [@deplate.variables["classOptions"]]
+        acc += options
+        acc.compact!
+        @deplate.variables["classOptions"] = acc.join(' ')
+    end
+    # Properly format +text+ as formatter-valid plain text.
+    #
+    # If +escaped+ is true, +text+ appears in a special context and was
+    # escaped by a backslash or similar.
+    #
+    # If a block is given, convert normal text using this block.
+    #
+    # Special characters are translated on the basis of @special_symbols.
+    def plain_text(text, escaped=false)
+        if defined?(@plain_text_rx)
+            acc = []
+            text.split(@plain_text_rx).each_with_index do |e, i|
+                if i.modulo(2) == 0
+                    acc << plain_text_recode(e) unless e.empty?
+                else
+                    r = @special_symbols[e]
+                    case r
+                    when String
+                        acc << r
+                    when Proc
+                        acc << r.call(escaped)
+                    else
+                        raise "Internal error: Strange symbol replacement for '#{e}'"
+                    end
+                end
+            end
+            acc.join
+        else
+            plain_text_recode(text)
+        end
+    end
+    # Recode normal text for #plain_text
+    def plain_text_recode(text)
+        text
+    end
+    def encode_id(id)
+        id ? Deplate::Core.clean_file_name(id, "__") : id
+    end
+    def label_mode
+        self.class.label_mode
+    end
+    def label_once
+        self.class.label_once
+    end
+    def label_delegate
+        self.class.label_delegate
+    end
+    def suffix
+        self.class.suffix
+    end
+    def formatter_name
+        self.class.myname
+    end
+    def formatter_rx
+        self.class.rx
+    end
+    def setup
+    end
+    def pre_process
+    end
+    def prepare
+    end
+    def matches?(text)
+        if text[0..0] == "~"
+            rv = (formatter_name =~ Regexp.new(text[1..-1]))
+        else
+            rv = (text =~ formatter_rx)
+        end
+        return rv ? true : false
+    end
+    def format_GET(invoker)
+        elt = invoker.elt
+        if elt
+            elt.format_clip(invoker, Deplate::Element)
+        else
+            invoker.log("Dropped!", :error)
+        end
+    end
+    def format_LIST(invoker)
+        acc  = []
+        elt  = invoker.elt
+        meth = "format_list_of_" + elt
+        if respond_to?(meth)
+            args = invoker.args
+            begin
+                acc << send(meth, invoker)
+                acc << format_pagebreak(invoker) if args["page"]
+            rescue StandardError => e
+                log(["Formatting on LIST failed", elt.inspect, e, e.backtrace[0..10]], :error)
+            end
+        else
+            log(["Unknown LIST type", elt.inspect], :error)
+        end
+        join_blocks(acc)
+    end
+    def format_PAGEBREAK(invoker)
+        format_pagebreak(invoker, nil, true)
+    end
+    def fill_in_template(invoker)
+        invoker.elt
+    end
+    def read_bib(bibfiles)
+    end
+    def format_unknown(invoker)
+        log(["Unknown element", invoker.class], :error, invoker.source)
+        elt = invoker.elt
+        if elt.kind_of?(Array)
+            elt = elt.join("\n")
+        end
+        format_verbatim(invoker, elt)
+    end
+    def format_unknown_particle(invoker)
+        return plain_text(invoker.args[:match][0])
+    end
+    def format_unknown_macro(invoker)
+        return %{#{plain_text("{")}#{invoker.elt}#{plain_text("}")}}
+    end
+    ### General
+    def_abstract :format_label, :format_figure, :include_image
+    ### Elements
+    def_abstract :format_note, :format_table, :format_heading, :format_list,
+        :format_break, :format_anchor, :format_paragraph
+    ### Regions
+    def_abstract :format_verbatim, :format_abstract, :format_quote,
+        :format_header, :format_footer
+    ### Commands
+    def_abstract :format_title, :format_MAKEBIB, :format_IDX,
+        :format_pagebreak
+    ### Particles
+    def_abstract :format_emphasize, :format_code, :format_url, :format_wiki, :format_symbol,
+        :doublequote_open, :doublequote_close, :singlequote_open, :singlequote_close
+    ### Macros
+    def_abstract :format_index, :format_footnote, :format_ref,
+        :format_linebreak, :format_subscript, :format_superscript, :format_stacked,
+        :format_pagenumber
+    def format_cite(invoker)
+        container = invoker.container
+        args = invoker.args
+        n    = args['n']
+        p    = args['p']
+        np   = args['np']
+        y    = args['y']
+        acc  = []
+        pmsg = @deplate.msg('p.\\ ')
+        for c in invoker.elt
+            cc = bib_entry(c)
+            if cc
+                yr = cc.assoc('year')
+                yr = if yr then yr[1] else '' end
+                if p
+                    p = @deplate.parse_and_format_without_wikinames(container, "#{pmsg}#{p}")
+                    yr += ": #{p}"
+                    # yr  += ": " + p if p
+                end
+                if y
+                    acc << referenced_bib_entry(invoker, c, yr)
+                else
+                    nm = cc.assoc('author') || cc.assoc('editor') || cc.assoc('howpublished')
+                    if nm
+                        nm = nm[1]
+                        nm = nm.gsub(/\s+/, ' ').split(' and ').collect do |a|
+                            a.scan(/\w+$/)
+                        end
+                        nm   = nm.join(', ')
+                        acc << referenced_bib_entry(invoker, c, [nm, yr].join(' '))
+                    else
+                        acc << referenced_bib_entry(invoker, c, c)
+                    end
+                end
+            end
+        end
+        n &&= n + plain_text(' ', true)
+        acc = acc.join('; ')
+        if np
+            return %{#{plain_text(' ', true)}#{n}#{acc}}
+        else
+            return %{#{plain_text(' ', true)}(#{n}#{acc})}
+        end
+    end
+    # Check if ch (a number representing a character) is a multi-byte leader.
+    # This method always returns false unless it is overwritten by some module.
+    def multibyte_leader?(ch)
+        false
+    end
+    # Return the first character of string while taking care whether string
+    # starts with a multi-byte sequence. Return the character in upper case if
+    # upcase is true (this usually doesn't work for multi-byte characters.
+    def get_first_char(string, upcase=false)
+        ch = string[0..0]
+        upcase and ch ? ch.upcase : ch
+    end
+    # Return the alphabethically sorted index data.
+    # def sort_index_entries(data)
+    #     return data.sort do |a,b|
+    #         aa = get_first_char(a, true)
+    #         bb = get_first_char(b, true)
+    #         aa <=> bb
+    #     end
+    # end
+    def sort_index_entries(data)
+        return data.sort {|a,b| a[0].upcase <=> b[0].upcase}
+    end
+    # Return the maximum row size for the table data in elt.
+    def table_row_size(elt)
+        max = 0
+        for row in elt
+            i = row.cols.size
+            if i > max
+                max = i
+            end
+        end
+        max
+    end
+    # Takes an optional block that takes a string as argument and returns
+    # true if we shouldn't wrap the text at this position
+    def wrap_text(text, args={})
+        moreIndent  = args[:indent]    || ""
+        innerMargin = args[:margin]    || 66
+        outerMargin = args[:maxmargin] || 72
+        hanging     = args[:hanging]   || nil
+        hang_idt    = hanging ? " " * hanging : nil
+        acc         = []
+        block       = args[:check]
+        break_at    = args[:break_at]
+        if break_at
+            rx = /(\s+|([#{break_at}]+))/
+        else
+            rx = /\s+/
+        end
+        text.each do |text|
+            m     = /^(\s*)(.*)$/.match(text)
+            idt   = m[1] + moreIndent
+            accum = [m[1]]
+            idtx  = idt.size
+            imx   = innerMargin - idtx
+            rest  = m[2]
+            while rest
+                this, rest = break_line(rest, rx, imx, block)
+                accum << this
+                if rest
+                    accum << "\n"
+                    accum << idt
+                    accum << hang_idt if hang_idt
+                end
+            end
+            acc << accum.join
+        end
+        return acc.join("\n")
+    end
+    def break_line(line, rx, inner_margin, block=nil, delta=-1)
+        max = line.size
+        if inner_margin >= max
+            return line, nil
+        else
+            m = rx.match(line[inner_margin..-1])
+            if m
+                pre = m.pre_match
+                tt  = line[0..inner_margin-1] + pre
+                if block and block.call(tt)
+                    return break_line(line, rx, inner_margin + delta, block, delta)
+                else
+                    if m[1]
+                        x = m[1].size + 1
+                        return tt[0..-x], m[1] + m.post_match
+                    else
+                        return tt, m.post_match
+                    end
+                end
+            else
+                return break_line(line, rx, inner_margin + 1, block, 1)
+            end
+        end
+    end
+    def prelude(name)
+        @deplate.variables[name]
+    end
+    # Format the Inlatex region
+    def format_inlatex(invoker)
+        args   = invoker.args
+        inline = args["inline"]
+        args["h"] ||= (args["inlineLatexHeight"] || args["inlatexHeight"]) if inline
+        acc    = []
+        elt    = invoker.elt
+        if elt
+            for i in elt
+                acc << format_element(:format_figure, invoker, inline, i)
+            end
+        else
+            invoker.log(['Empty element', 'inlatex'], :error)
+        end
+        join_blocks(acc)
+    end
+    # Format the ltx macro
+    def format_ltx(invoker, other_args={})
+        args = invoker.args
+        acc  = []
+        args["h"]   ||= (args["inlineLatexHeight"] || other_args["h"])
+        args["alt"] ||= invoker.text
+        args["style"] = "latex"
+        inlatex = invoker.elt
+        if !inlatex or inlatex.empty?
+            acc << invoker.text
+        else
+            for i in inlatex
+                # acc << @deplate.formatter.include_image(i, args, true)
+                acc << format_element(:format_figure, invoker, true, i)
+            end
+        end
+        return acc.flatten.join("\n")
+    end
+    # Format the math macro
+    alias :format_math :format_ltx
+    # Process inline latex. The file names of the output are saved as an
+    # array in <tt>invoker.elt</tt>.
+    def inlatex(invoker)
+        pkgs, body = inlatex_split(invoker.accum)
+        id      = inlatex_id(invoker)
+        sfx     = invoker.args["sfx"] || @deplate.variables['ltxSfx'] || inlatex_sfx
+        currDir = Dir.pwd
+        @deplate.in_working_dir do
+            ftex    = id + ".tex"
+            flog    = id + ".log"
+            faux    = id + ".aux"
+            fdvi    = id + ".dvi"
+            fps     = id + ".ps"
+            checkOW = true
+            case sfx
+            when "ps"
+                device  = nil
+                fout    = fps
+                checkOW = false
+            when "pdf"
+                device  = "pdfwrite"
+                fout    = id + ".*.pdf"
+            when "jpeg", "jpg"
+                device  = "jpeg"
+                fout    = id + ".*.jpeg"
+            else
+                raise "Unknown device/suffix: #{sfx}"
+            end
+            acc = [
+                "\\documentclass[12pt,a4paper,notitlepage]{article}",
+                "\\usepackage{amsmath}",
+                "\\usepackage{amsfonts}",
+            ]
+            acc += pkgs
+            acc << "\\begin{document}" << "\\pagestyle{empty}"
+            acc += body
+            acc << "\\end{document}"
+            if Deplate::Region.check_file(invoker, fout, ftex, acc)
+                invoker.log(["Files exist! Using", fout], :anyway)
+            else
+                if checkOW and !@deplate.options.force
+                    for f in [ftex, flog, faux, fdvi, fout]
+                        if !Dir[f].empty?
+                            raise "Please delete '#{f}' or change the id before proceeding:\n#{invoker.accum.join("\n")}"
+                        end
+                    end
+                end
+                acc = acc.join("\n")
+                Deplate::External.write_file(invoker, ftex) {|io| io.puts(acc)}
+                inlatex_process_latex(invoker, ftex, faux, flog)
+                if block_given?
+                    yield(invoker, device, fdvi, fps, fout)
+                else
+                    inlatex_process_dvi(invoker, fdvi, fps) if File.exist?(fdvi)
+                    if device
+                        inlatex_process_ps(invoker, device, fps, fout, invoker.args)
+                    elsif fps != fout
+                        File.rename(fps, fout)
+                    end
+                end
+            end
+            invoker.elt = Dir[fout]
+            if invoker.elt.empty?
+                code = invoker.accum.join("\n")
+                invoker.log(["Conversion if Inline LaTeX failed", code], :error)
+            end
+        end
+    end
+    def inlatex_id(invoker, last=false)
+        id = invoker.args["id"]
+        unless id
+            unless last
+                @inlatex_idx += 1
+            end
+            id = @deplate.auxiliary_auto_filename('ltx', @inlatex_idx, invoker.accum)
+            invoker.log(["No id given", invoker.accum])
+        end
+        id
+    end
+    def inlatex_process_latex(invoker, ftex, faux, flog)
+        latex2dvi(invoker, ftex, faux, flog)
+    end
+    def inlatex_process_dvi(invoker, fdvi, fps)
+        dvi2ps(invoker, fdvi, fps)
+    end
+    def inlatex_process_ps(invoker, device, fps, fout, args)
+        ps2img(invoker, device, fps, fout, args) if File.exist?(fps)
+    end
+    # Divert lines in invoker#accum to the preamble or the body.
+    def inlatex_split(accum)
+        pkgs = []
+        body = []
+        for l in accum.join("\n")
+            if l =~ /^\s*\\(usepackage|input)\s*(\[.*?\])?\s*\{.+?\}\s*$/
+                pkgs << l.chomp
+            elsif l =~ /%%%\s*$/
+                pkgs << l.chomp
+            else
+                body << l.chomp
+            end
+        end
+        return pkgs.uniq, body
+    end
+    # The default suffix/device to be used for inlatex output.
+    def inlatex_sfx
+        "jpeg"
+    end
+    def latex2dvi(invoker, ftex, faux, flog)
+        if Deplate::External.latex(invoker, ftex) and @deplate.options.clean
+            for i in [faux, flog]
+                if File.exist?(i)
+                    File.delete(i)
+                    invoker.log(["Deleting", i])
+                end
+            end
+        end
+    end
+    def dvi2ps(invoker, fdvi, fps, other_options=nil)
+        # -Pwww
+        if Deplate::External.dvi2ps(invoker, fdvi, fps, other_options) and @deplate.options.clean
+            File.delete(fdvi) if @deplate.options.clean
+            invoker.log(["Deleting", fdvi])
+        end
+    end
+    def ps2img(invoker, device, fps, fout, args)
+        if Deplate::External.ps2img(invoker, device, fps, fout, args) and @deplate.options.clean
+            File.delete(fps)
+            invoker.log(["Deleting", fps])
+        end
+    end
+    private
+    def referenced_bib_entry(invoker, key, text)
+        text
+    end
+    def formatted_block(env, text, opts=nil, args=nil, no_id=false, no_indent=false)
+        text = indent_text(text) unless no_indent
+        return join_blocks([get_open(env, opts, args, :no_id => no_id), text, get_close(env, args)])
+    end
+    def_abstract :get_open, :get_close
+    def formatted_inline(env, text, opts=nil, args=nil, no_id=false)
+        return join_inline([get_open(env, opts, args, :no_id => no_id), text, get_close(env, args)])
+    end
+    def formatted_single(env, opts=nil, args=nil, no_id=false)
+        return get_open(env, opts, args, :single => true, :no_id => no_id)
+    end
+    def use_id(args, opts={}, set=true)
+        if args
+            set &&= !args[:id]
+        else
+            args = {}
+        end
+        id = opts['id'] || args[:id] || args['id']
+        # || args['label']
+        args[:id] = id if set
+        id
+    end
+    def use_labels(args, labels, opts={})
+        args   ||= {}
+        labels   = labels ? labels.dup : []
+        id = use_id(args, opts)
+        l  = args["label"]
+        labels << l if l
+        # i  = opts[:invoker]
+        # if i
+        #     labels += i.label
+        # end
+        if opts[:with_id]
+            labels << id
+        elsif id
+            labels.delete(id)
+        end
+        labels.delete_if {|e| @consumed_labels.include?(e)}
+        labels.flatten!
+        labels.compact!
+        labels.uniq!
+        @consumed_labels += labels unless labels.empty?
+        return labels
+    end
+    def format_indent(level, shift=false)
+        if level < 0
+            log(["Negative indentation level", level], :error)
+            return ""
+        else
+            l = level * 2
+            # l += 1 if shift
+            return "  " * l
+        end
+    end
+    def indent_text(text, mult=1, shift=false)
+        if text
+            indent = format_indent(mult)
+            return text.collect {|l| "%s%s" % [indent, l.chomp]}.join("\n")
+        end
+    end
+    def keywords
+        kw = @deplate.variables["keywords"]
+        if kw.kind_of?(Array)
+            kw
+        elsif kw.kind_of?(String)
+            kw.split(/\s*[,;]\s*/)
+        elsif kw
+            log(["Shouldn't be here", kw, kw.class], :error)
+        else
+            nil
+        end
+    end
+    # Create @plain_text_rx, which contains the keys of @special_symbols
+    # in a group. This rx will be used by #plain_text.
+    def build_plain_text_rx
+        @plain_text_rx = Regexp.new("(%s)" % @special_symbols.keys.collect {|x| Regexp.escape(x)}.join("|"))
+    end
+    ################################################ Bibliography {{{1
+    def simple_bibtex_reader(bibfiles)
+        acc = []
+        for b in bibfiles
+            b = File.expand_path(b)
+            unless File.exist?(b)
+                b = Deplate::External.kpsewhich(self, b)
+                if b.empty?
+                    next
+                end
+            end
+            File.open(b) {|io| acc << io.read}
+        end
+        acc = acc.join("\n")
+        loop do
+            m = /^\s*(@\w+\{\s*(\S+?)\s*,.*?)(?=(^@|\z))/m.match(acc)
+            if m
+                id = m[2]
+                e  = m[1]
+                arr = e.scan(/^\s*(\w+)\s*=\s*(\{.*?\}|\d+)\s*[,}]\s*$/m)
+                arr.collect! do |var, val, rest|
+                    n = /^\s*\{(.*?)\}\s*($|\}\s*\z)/m.match(val)
+                    if n
+                        val = n[1]
+                    end
+                    [var, val]
+                end
+                arr << ["type", m[2]]
+                @bibentries[id] = arr
+                acc = m.post_match
+            else
+                break
+            end
+        end
+    end
+    def cited_keys
+        @deplate.options.citations.collect {|c| c.elt}.flatten.uniq
+    end
+    def format_bibliography(invoker)
+        acc  = []
+        for k in cited_keys
+            b  = bib_entry(k)
+            bb = format_bib_entry(invoker, b)
+            i  = encode_id(k)
+            l  = format_label(invoker, :string, [i])
+            if block_given?
+                acc << [yield(i, l, bb), bb]
+            else
+                acc << [bb, bb]
+            end
+        end
+        acc = acc.sort {|a,b| a[1] <=> b[1]}
+        acc.collect! {|e| e[0]}
+        join_blocks(acc)
+    end
+    def format_bib_entry(invoker, bibdef)
+        key, author = bibdef.assoc("author")
+        key, editor = bibdef.assoc("editor")
+        key, how    = bibdef.assoc("howpublished")
+        author = reformat_authors(author)
+        editor = reformat_authors(editor)
+        au     = [nil, author || editor || how || "???"]
+        yr     = bibdef.assoc("year")
+        au[1]  = "%s (%s)" % [au, yr[1]] if yr
+        ti     = bibdef.assoc("title")
+        bt     = bibdef.assoc("booktitle")
+        pu     = bibdef.assoc("publisher")
+        i      = bibdef.assoc("journal")
+        if i
+            vol = bibdef.assoc("volume")
+            vol &&= vol[1]
+            nr  = bibdef.assoc("number")
+            nr  &&= "(" + nr[1] +")"
+            i[1] += [" ", vol, nr].join if vol or nr
+        elsif author and editor
+            i = [nil, editor]
+            t = bt || ti
+            if t
+                i << ": " << t[1]
+            end
+        end
+        p  = bibdef.assoc("pages")
+        if i
+            hi = "journal"
+        elsif bt
+            hi = "booktitle"
+        else
+            hi = "title"
+        end
+        bb = [au, ti, bt, pu, i, p].compact.collect do |key, val|
+            val = simple_latex_reformat(val)
+            val = %{__#{val}__} if key == hi
+            val
+        end
+        return @deplate.parse_and_format_without_wikinames(invoker, bb.join(". ") + ".")
+    end
+    def simple_latex_reformat(text)
+        text.gsub!(/^\{(.*)\}$/, "\\1")
+        text.gsub!(/\s+/m, " ")
+        text.gsub!(/``/, %{"})
+        text.gsub!(/''/, %{"})
+        text.gsub!(/`/,  %{'})
+        text.gsub!(/'/,  %{'})
+        # text.gsub!(/--/, %{--})
+        text.gsub!(/\\([$&%#_{}^~|])(\{\})?/, "\\1")
+        return text
+    end
+    def bib_entry(key)
+        b = @bibentries[key] || []
+        crossref = b.assoc("crossref")
+        if crossref
+            cb = @bibentries[crossref[1]]
+            b += cb if cb
+        end
+        return b
+    end
+    def reformat_authors(text)
+        if text
+            au = []
+            for a in text.split(/ and /)
+                m = /^((.+?)?\s+)?(\S+)$/.match(a.strip)
+                if m[2]
+                    au << m[3] + ", " + m[2]
+                else
+                    au << a
+                end
+            end
+            return au.join("; ")
+        end
+    end
+    def authors_split(text)
+        text.split(/ and /) if text
+    end
+    # this is the general function used for formatting lists of any kind; it
+    # relies on #format_list, #format_indent and #format_list_item to
+    # do the actual output
+    def printable_list(invoker, list=nil)
+        list  ||= invoker.elt
+        unless list.nil? or list.empty?
+            @levels  = []
+            @types   = []
+            @endTags = []
+            accum    = []
+            # level0  = list.sort {|a,b| a.level <=> b.level}[0].level
+            level0   = list.min {|a,b| a.level <=> b.level}.level
+            ind      = 0
+            max      = list.size - 1
+            list.each_with_index do |i, idx|
+                # :listtype, :type, :level, :item, :body
+                t = i.type
+                s = list_subtype(t, i.item)
+                c = [i.listtype, s]
+                l = i.level
+                if last_listtype
+                    # there is a list environment, so this isn't the first item
+                    if last_level and l != last_level
+                        if l < last_level
+                            # close a nested list
+                            ind = printable_close_lists_until(invoker, accum, ind, l)
+                        elsif l > last_level and t != "Paragraph"
+                            # open a new nested list
+                            # p "DBG           --- 1054: #{c} != #{last_listtype}"
+                            ind = printable_open_list(invoker, accum, c, ind, l, s)
+                            @endTags << nil
+                        end
+                    end
+                    if last_level and last_listtype and c != last_listtype and t != "Paragraph"
+                        if l <= last_level
+                            # close the previous list and start a new one
+                            ind = printable_list_close_endtag(invoker, accum, ind)
+                            # p "DBG             ---- #{last_listtype} #{t}"
+                        end
+                        if c != last_listtype and l <= last_level
+                            # p "DBG           --- 1067: #{c} != #{last_listtype}"
+                            ind = printable_close_list(invoker, accum, ind)
+                            ind = printable_open_list(invoker, accum, c, ind, l, s)
+                            @endTags << nil
+                        end
+                    end
+                else
+                    # start a new list
+                    ind = printable_open_list(invoker, accum, c, ind, l, s)
+                end
+                if @levels.empty? and idx < max
+                    # something weired happened (e.g. the previous list item was
+                    # deeper nested, but this item doesn't continue anything --
+                    # which should probably considered as a syntax error anyway)
+                    invoker.log(["Malformed list hierarchy", last_listtype, idx], :error)
+                    ind = printable_open_list(invoker, accum, c, ind, l, s)
+                end
+                if t == "Paragraph"
+                    acc, etag = format_list_item(invoker, t, ind, i)
+                    accum << acc
+                else
+                    ind = printable_list_close_endtag(invoker, accum, ind)
+                    # p "DBG #{' ' * l} Item (#{@types} #{@levels})"
+                    acc, etag = format_list_item(invoker, t, ind, i)
+                    @endTags << [etag, l, ind]
+                    accum << acc
+                    ind += 1
+                end
+                if i.label and !i.label.empty?
+                    lab = format_label(invoker, :string, i.label)
+                    if lab
+                        accum[-1] += lab
+                    end
+                end
+            end
+            # close all open tags & lists
+            while !@endTags.empty?
+                ind = printable_list_close_endtag(invoker, accum, ind)
+            end
+            while !@levels.empty?
+                ind = printable_close_list(invoker, accum, ind)
+            end
+            if ind < 0
+                invoker.log("Malformed list or internal error", :error)
+            end
+            accum.delete_if {|e| e == :empty}
+            return accum.join("\n")
+        else
+            return ""
+        end
+    end
+    def last_level
+        @levels.last
+    end
+    def last_listtype
+        @types.last
+    end
+    # def last_type
+    #     @types.last
+    # end
+    # def last_listtype
+    #     c, s = last_type
+    #     c
+    # end
+    # def last_subtype
+    #     c, s = last_type
+    #     s
+    # end
+    def list_subtype(type, item)
+        case type
+        when "Numbered"
+            if item =~ /^[A-Z]\.?$/
+                return "A"
+            elsif item =~ /^[a-z?@]\.?$/
+                return "a"
+            else
+                return "1"
+            end
+        when "Itemize"
+            return nil
+        when "Description"
+            return nil
+        when "Paragraph"
+            return nil
+        else
+            raise "Unknown list type: #{type}"
+        end
+    end
+    def printable_close_lists_until(invoker, accum, ind, level)
+        begin
+            ind = printable_list_close_endtag(invoker, accum, ind)
+            ind = printable_close_list(invoker, accum, ind)
+        end until @levels.empty? or @levels.last <= level
+        ind
+    end
+    def printable_close_list(invoker, accum, ind)
+        ind -= 1
+        lev  = @levels.pop
+        tp, sp = @types.pop
+        # p "DBG #{' ' * (lev || 1)}>close #{lev} #{tp} #{sp} #{caller[0]}"
+        le = format_list_env(invoker, tp, ind, :close, sp)
+        accum << le if le
+        ind
+    end
+    def printable_open_list(invoker, accum, type, ind, level, subtype=nil)
+        t, s = type
+        le = format_list_env(invoker, t,  ind, :open, subtype)
+        accum << le if le
+        ind += 1
+        @levels << level
+        @types  << type
+        # p "DBG #{' ' * (level || 1)}<open #{level} #{type} #{subtype} #{caller[0]}"
+        ind
+    end
+    def printable_list_close_endtag(invoker, accum, ind)
+        tag, level, ind0 = @endTags.pop
+        if tag
+            while @levels.last and @levels.last > level
+                ind = printable_close_list(invoker, accum, ind)
+            end
+            accum << tag unless tag == :none
+        end
+        return ind0 || ind
+    end
+    def list_item_explicit_value(item, explicit=false)
+        if @deplate.variables['noExplicitNumbering']
+            nil
+        elsif explicit or item.explicit and item.item and !item.item.empty?
+            item.item
+        else
+            nil
+        end
+    end
+end