RubyGems - deplate - Versions diffs - 0.7.3 - Mend

deplate 0.7.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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