deplate 0.7.3 → 0.8

data/lib/deplate/formatter.rb

@@ -3,10 +3,11 @@
 # @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
+# @Last Change: 05-Jun-2006.
+# @Revision:    0.1443
 
-require "deplate/abstract-class"
+require 'deplate/abstract-class'
+require 'deplate/common'
 
 # Description:
 # An abstract formatter class
@@ -18,7 +19,32 @@ require "deplate/abstract-class"
 # CHANGES:
 # 
 
-class Deplate::Formatter
+class Deplate::Formatter < Deplate::CommonObject
+    class_attribute :formatter
+
+    class_attribute :suffix
+    class_attribute :myname
+    class_attribute :related, []
+    class_attribute :rx
+    class_attribute :label_mode, :enclose
+    class_attribute :label_delegate, []
+    class_attribute :label_once, []
+    
+    class_attribute :naked_agents, [
+        :format_label,
+        :format_index,
+    ]
+
+    class_attribute :blacklist_latex, [
+        'include',  'def',  'command', 'loop', 'repeat', 
+        'open', 'toks', 'output', 'input', 'catcode', 'name', '^^', 
+        '\\every', '\\errhelp', '\\errorstopmode', '\\scrollmode', 
+        '\\nonstopmode', '\\batchmode', '\\read', '\\write', 'csname', 
+        '\\newhelp', '\\uppercase',  '\\lowercase', '\\relax', 
+        '\\aftergroup', '\\afterassignment', '\\expandafter', 
+        '\\noexpand', '\\special', '\\usepackage'
+    ]
+
     class << self
         def noop(context, name)
             context.module_eval %{
@@ -28,67 +54,54 @@ class Deplate::Formatter
             }
         end
 
-        attr_writer :suffix, :myname, :rx, :label_mode, :label_delegate, :label_once
+        def hook_post_myname=(name)
+            klass = self
+            Deplate::Core.class_eval {declare_formatter(klass)}
+        end
 
-        def get_class_attrib(name, default=nil)
-            if self == Deplate::Formatter
-                return default
+        # <+TBD+>Shouldn't services belong to the formatter?
+        def def_service(name, &block)
+            # prefix = @formatter.class.myname.gsub('\W', '__')
+            # method = ['svc', prefix, name].join('_')
+            method = ['svc', name].join('_')
+            self.class_eval do
+                define_method(method, &block)
             end
-            iv = "@#{name}"
-            if self.instance_variables.include?(iv)
-                val = self.instance_variable_get(iv)
-                if val
-                    return val
+            init  = ['formatter_initialize', method].join('_')
+            sname = name.gsub(/_(.)/) {$1.capitalize}
+            self.class_eval do
+                define_method(init) do
+                    @doc_services[name]  = method
+                    @doc_services[sname] = method
                 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_reader   :deplate
+    attr_reader   :advices
+    attr_reader   :expander
     attr_accessor :special_symbols
+    attr_accessor :bibentries
+    # A hash holding all known document services (names => method).
+    attr_accessor :doc_services
 
     def initialize(deplate, args={})
-        @deplate     = deplate
-        @variables   = deplate.variables
-        @bibentries  = {}
-        @open_labels = []
-        @advices     = args[:advices] || {}
-        @inlatex_idx = 0
-        @encodings   = {}
+        @deplate      = deplate
+        @variables    = deplate.variables
+        @advices      = args[:advices]      || {}
+        @doc_services = args[:doc_services] || initialize_services
+        @inlatex_idx  = 0
+        @encodings    = {}
+        @symbol_proxy = nil
+        reset!
+    end
+
+    def reset!
+        @bibentries      = {}
+        @open_labels     = []
         @consumed_labels = []
         @consumed_ids    = []
     end
@@ -139,6 +152,24 @@ class Deplate::Formatter
         end
     end
     
+    # Run a "service", i.e., a small, mostly autonomous function/method that 
+    # usually yields some formatted output.
+    def invoke_service(name, args={}, text='')
+        method = @doc_services[name]
+        if method
+            begin
+                return send(method, args || {}, text || '')
+            rescue Exception => e
+                puts e.backtrace[0..10].join("\n")
+                log(['Calling service failed', name, e], :error)
+            end
+        else
+            p "DBG"
+            puts @doc_services.keys.sort.join("\n")
+            log(['Unknown service', name], :error)
+        end
+    end
+
     def log(*args)
         Deplate::Core.log(*args)
     end
@@ -162,6 +193,10 @@ class Deplate::Formatter
         return table[cen] || cen
     end
     
+    def output_destination
+        @deplate.output.top_heading.destination || @deplate.options.out
+    end
+    
     def join_blocks(blocks)
         blocks.flatten.compact.join("\n")
     end
@@ -173,23 +208,37 @@ class Deplate::Formatter
     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)
+        rv = with_agent(agent, Array, invoker, *args)
+        if rv and !rv.empty? and !self.class.naked_agents.include?(agent)
+            wa = {}
+            wa[:styles] = invoker.styles if invoker.respond_to?(:styles)
+            rv = methods.find_all {|m| m =~ /^wrap_formatted_particle_/ }.
+                inject(rv) {|rv, m| send(m, invoker, rv, wa)}
+        end
+        rv    
     end
 
-    def format_particle_as_string(agent, object, *args)
-        join_inline(format_particle(agent, object, *args))
+    def format_particle_as_string(agent, invoker, *args)
+        join_inline(format_particle(agent, invoker, *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)
+        rv = with_agent(agent, Array, invoker, *args)
+        if rv and !rv.empty? and !self.class.naked_agents.include?(agent)
+            wa = {}
+            wa[:styles] = invoker.styles if invoker.respond_to?(:styles)
+            rv = methods.find_all {|m| m =~ /^wrap_formatted_element_/ }.
+                inject(rv) {|rv, m| send(m, invoker, rv, wa)}
+        end
+        rv    
     end
 
-    def format_element_as_string(agent, object, *args)
-        format_element(agent, object, *args)
+    def format_element_as_string(agent, invoker, *args)
+        format_element(agent, invoker, *args)
     end
-    
+
     def with_agent(agent, prototype, invoker, *args)
         log(["Call with agent", agent, invoker.class, args], :debug)
         if respond_to?(agent)
@@ -209,7 +258,7 @@ class Deplate::Formatter
                 prototype ||= inner.class
                 around = stylish[:wrap]
                 if around
-                    inner =  around.inject(inner) do |acc, advice|
+                    inner = around.inject(inner) do |acc, advice|
                         advice[:prc].call(agent, acc, invoker, *args)
                     end
                 end
@@ -247,7 +296,11 @@ class Deplate::Formatter
             return nil
         end
     end
-        
+
+    def dummy(invoker, *args)
+        args
+    end
+       
     def output(invoker, *body)
         output_at(invoker.doc_type, invoker.doc_slot, *body)
     end
@@ -318,6 +371,77 @@ class Deplate::Formatter
         end
     end
 
+    def check_symbol_proxy
+        unless @symbol_proxy
+            pre_process
+        end
+    end
+
+    def symbol_quote(invoker)
+        check_symbol_proxy
+        @symbol_proxy.symbol_quote(invoker)
+    end
+
+    def symbol_gt(invoker)
+        check_symbol_proxy
+        @symbol_proxy.symbol_gt(invoker)
+    end
+
+    def symbol_lt(invoker)
+        check_symbol_proxy
+        @symbol_proxy.symbol_lt(invoker)
+    end
+
+    def symbol_amp(invoker)
+        check_symbol_proxy
+        @symbol_proxy.symbol_amp(invoker)
+    end
+
+    def doublequote_open(invoker)
+        check_symbol_proxy
+        @symbol_proxy.doublequote_open(invoker)
+    end
+
+    def doublequote_close(invoker)
+        check_symbol_proxy
+        @symbol_proxy.doublequote_close(invoker)
+    end
+
+    def singlequote_open(invoker)
+        check_symbol_proxy
+        @symbol_proxy.singlequote_open(invoker)
+    end
+
+    def singlequote_close(invoker)
+        check_symbol_proxy
+        @symbol_proxy.singlequote_close(invoker)
+    end
+
+    def nonbreakingspace(invoker)
+        check_symbol_proxy
+        @symbol_proxy.nonbreakingspace(invoker)
+    end
+
+    def symbol_paragraph(invoker)
+        check_symbol_proxy
+        @symbol_proxy.symbol_paragraph(invoker)
+    end
+
+    def format_symbol(invoker, sym)
+        check_symbol_proxy
+        @symbol_proxy.format_symbol(invoker, sym)
+    end
+    
+    def format_plain_text(invoker, text=nil, escaped=false)
+        text ||= invoker.match
+        # <+TBD+> escaped
+        plain_text(text, escaped)
+    end
+
+    def format_void(invoker, text=nil)
+        text || invoker.elt
+    end
+    
     # Recode normal text for #plain_text
     def plain_text_recode(text)
         text
@@ -381,17 +505,27 @@ class Deplate::Formatter
     def format_LIST(invoker)
         acc  = []
         elt  = invoker.elt
+        case elt
+        when 'contents'
+            elt = 'toc'
+        when 'tables'
+            elt = 'lot'
+        when 'figures'
+            elt = 'lof'
+        end
         meth = "format_list_of_" + elt
-        if respond_to?(meth)
-            args = invoker.args
-            begin
+        args = invoker.args
+        begin
+            if respond_to?(meth)
                 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)
+            elsif @deplate.options.listings.is_defined?(elt)
+                acc << format_custom_list(invoker, elt)
+            else
+                log(["Unknown list type", elt.inspect], :error)
             end
-        else
-            log(["Unknown LIST type", elt.inspect], :error)
+            acc << format_pagebreak(invoker) if args["page"]
+        rescue StandardError => e
+            log(["Formatting on LIST failed", elt.inspect, e, e.backtrace[0..10]], :error)
         end
         join_blocks(acc)
     end
@@ -407,6 +541,20 @@ class Deplate::Formatter
     def read_bib(bibfiles)
     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 referenced_bib_entry(invoker, key, text)
+        text
+    end
+
     def format_unknown(invoker)
         log(["Unknown element", invoker.class], :error, invoker.source)
         elt = invoker.elt
@@ -426,7 +574,7 @@ class Deplate::Formatter
 
 
     ### General
-    def_abstract :format_label, :format_figure, :include_image
+    def_abstract :format_label, :format_figure, :include_image, :image_suffixes
     
     ### Elements
     def_abstract :format_note, :format_table, :format_heading, :format_list, 
@@ -441,8 +589,9 @@ class Deplate::Formatter
         :format_pagebreak
 
     ### Particles
-    def_abstract :format_emphasize, :format_code, :format_url, :format_wiki, :format_symbol, 
-        :doublequote_open, :doublequote_close, :singlequote_open, :singlequote_close
+    def_abstract :format_emphasize, :format_code, :format_url, :format_wiki
+    # def_abstract :format_symbol, :doublequote_open, :doublequote_close, 
+    #     :singlequote_open, :singlequote_close
 
     ### Macros
     def_abstract :format_index, :format_footnote, :format_ref, 
@@ -450,48 +599,7 @@ class Deplate::Formatter
         :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
+        bib_styler.bib_cite(invoker)
     end
 
     # Check if ch (a number representing a character) is a multi-byte leader. 
@@ -532,14 +640,18 @@ class Deplate::Formatter
         max
     end
 
+    def table_empty_cell
+        ''
+    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]    || ""
+        moreIndent  = args[:indent]    || ''
         innerMargin = args[:margin]    || 66
         outerMargin = args[:maxmargin] || 72
         hanging     = args[:hanging]   || nil
-        hang_idt    = hanging ? " " * hanging : nil
+        hang_idt    = hanging ? ' ' * hanging : nil
         acc         = []
         block       = args[:check]
         break_at    = args[:break_at]
@@ -571,6 +683,7 @@ class Deplate::Formatter
     
     def break_line(line, rx, inner_margin, block=nil, delta=-1)
         max = line.size
+        # p "DBG #{max} -- #{inner_margin}: #{line}"
         if inner_margin >= max
             return line, nil
         else
@@ -606,7 +719,7 @@ class Deplate::Formatter
         acc    = []
         elt    = invoker.elt
         if elt
-            for i in elt
+            elt.each do |i|
                 acc << format_element(:format_figure, invoker, inline, i)
             end
         else
@@ -627,7 +740,7 @@ class Deplate::Formatter
             acc << invoker.text
         else
             for i in inlatex
-                # acc << @deplate.formatter.include_image(i, args, true)
+                # acc << @deplate.formatter.include_image(invoker, i, args, true)
                 acc << format_element(:format_figure, invoker, true, i)
             end
         end
@@ -667,10 +780,13 @@ class Deplate::Formatter
                 raise "Unknown device/suffix: #{sfx}"
             end
 
+            pointsize = invoker.args['pointsize'] || 
+                @deplate.variables['latexPointsize'] || '10'
             acc = [
-                "\\documentclass[12pt,a4paper,notitlepage]{article}",
+                "\\documentclass[#{pointsize}pt,a4paper,notitlepage]{article}",
                 "\\usepackage{amsmath}",
                 "\\usepackage{amsfonts}",
+                "\\usepackage{amssymb}",
             ]
             acc += pkgs
             acc << "\\begin{document}" << "\\pagestyle{empty}"
@@ -719,7 +835,7 @@ class Deplate::Formatter
                 @inlatex_idx += 1
             end
             id = @deplate.auxiliary_auto_filename('ltx', @inlatex_idx, invoker.accum)
-            invoker.log(["No id given", invoker.accum])
+            invoker.log(["No ID given", invoker.accum])
         end
         id
     end
@@ -741,6 +857,7 @@ class Deplate::Formatter
         pkgs = []
         body = []
         for l in accum.join("\n")
+            l = inlatex_clean(l)
             if l =~ /^\s*\\(usepackage|input)\s*(\[.*?\])?\s*\{.+?\}\s*$/
                 pkgs << l.chomp
             elsif l =~ /%%%\s*$/
@@ -751,10 +868,30 @@ class Deplate::Formatter
         end
         return pkgs.uniq, body
     end
+    
+    rx = self.blacklist_latex.collect! do |c|
+        if c =~ /^\\(.+)$/
+            "\\\\\\s*#$1\\b"
+        elsif c =~ /\w$/
+            # "(\\\\\\s*)?\\b#{Regexp.escape(c)}\\b"
+            "\\\\\\s*#{Regexp.escape(c)}\\b"
+        else
+            Regexp.escape(c)
+        end
+    end
+    INLATEX_RX = Regexp.new(rx.join('|'))
 
+    def inlatex_clean(line)
+        line = line.chomp
+        unless @deplate.options.allow.include?('t')
+            line.gsub!(INLATEX_RX, '+++disabled+++')
+        end
+        line
+    end
+    
     # The default suffix/device to be used for inlatex output.
     def inlatex_sfx
-        "jpeg"
+        'jpeg'
     end
 
     def latex2dvi(invoker, ftex, faux, flog)
@@ -783,12 +920,6 @@ class Deplate::Formatter
         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)])
@@ -804,6 +935,184 @@ class Deplate::Formatter
         return get_open(env, opts, args, :single => true, :no_id => no_id)
     end
 
+    def indent_text(text, args={})
+        if text
+            mult    = args[:mult] || 1
+            shift   = args[:shift]
+            hanging = args[:hanging]
+            indent  = args[:indent] || format_indent(mult, shift)
+            return text.collect do |l|
+                rv = '%s%s' % [indent, l.chomp]
+                if hanging
+                    indent = args[:indenttail] || \
+                        if args[:indent]
+                            args[:indent] + 
+                                case hanging
+                                when Integer
+                                ' ' * hanging
+                                else
+                                '    '
+                                end
+                        else
+                            format_indent(mult + 1, shift)
+                        end
+                    hanging = false
+                end
+                rv
+            end.join("\n")
+        end
+    end
+
+    def_service('object') do |args, text|
+        id = args['id']
+        if id
+            return @deplate.object_by_id(id)
+        elsif args['array']
+            text = args['array']
+            sep = args['sep']
+            if sep
+                sep  = sep ? Regexp.escape(sep) : '\\s+'
+            else
+                sep = args['rx']
+            end
+            if sep
+                return text.split(Regexp.new(sep))
+            else
+                log('No separator', :error)
+            end
+        end
+    end
+
+    def_service('output_filename') do |args, text|
+        output_destination
+    end
+    
+    def_service('output_basename') do |args, text|
+        sfx = args['sfx']
+        if sfx
+            File.basename(output_destination, sfx)
+        else
+            File.basename(output_destination)
+        end
+    end
+    
+    # <+TBD+>
+    # def_service('format') do |args, text|
+    #     id = args['id'] || text
+    #     # o  = @variables[id]
+    #     o  = object_by_id(id)
+    #     if o
+    #         o.format_as_string
+    #     end
+    # end
+
+
+    private
+    def initialize_services
+        services = {}
+        return services
+    end
+
+    def format_custom_list(invoker, elt)
+        listing = @deplate.options.listings.get(elt, true)
+        props   = listing[:props]
+        format_list_of(invoker,
+                       :title => props['title'],
+                       :prefix => props['prefix'] || elt,
+                       :data  => listing[:value],
+                       :flat  => props['flat'],
+                       :style => (props['style'] || props['prefix'])
+                      )
+    end
+    
+    def format_list_of(invoker, other_args)
+        args   = invoker.args
+        name   = other_args[:title]
+        prefix = other_args[:prefix]
+        data   = other_args[:data]
+        unless data
+            list = other_args[:listing]
+            data = invoker.deplate.options.listings.get(list)
+            unless data
+                invoker.log(['Unknown list', list], :error)
+            end
+        end
+        name = args['title'] || name
+        id   = (name || prefix).gsub(/\W/, '_')
+        
+        acc  = []
+        consume_label(id, true)
+        consume_label("#{id}Block", true)
+        acc << listing_prematter(invoker, other_args, id)
+        unless args['plain'] || args['noTitle']
+            acc << listing_title(invoker, other_args, name)
+        end
+        
+        ll = 1
+        levels = args['levels']
+        if levels
+            range_from, range_to, rest = levels.split(/\.\./)
+            if rest
+                log(['Malformed range', levels], :error)
+            end
+        end
+        range_from ||= args['min']
+        if range_from
+            range_from = range_from.to_i
+        end
+        range_to ||= args['max']
+        if range_to
+            range_to = range_to.to_i
+        end
+        top = args['top']
+        if top
+            top = /^#{Regexp.escape(top)}/
+        end
+        sub = args['sub']
+        if sub
+            sub = /^#{Regexp.escape(invoker.level_as_string)}\./
+        end
+        accData = []
+        for elt in data
+            if elt.nil? or elt.args['noList']
+                next
+            end
+            if range_from and elt.level < range_from
+                next
+            end
+            if range_to and elt.level > range_to
+                next
+            end
+            if top and elt.level_as_string !~ top
+                next
+            end
+            if sub and elt.level_as_string !~ sub
+                next
+            end
+            title = block_given? ? yield(elt) : elt.element_caption
+            level = other_args[:flat] ? 1 : elt.level
+            accData << listing_item(invoker, args, prefix, title, elt, level, other_args)
+        end
+        acc << printable_list(invoker, accData)
+        acc << listing_postmatter(invoker, other_args)
+        join_blocks(acc)
+    end
+
+    def_abstract :listing_prematter, :listing_postmatter, :listing_title, \
+        :listing_item
+
+    def consume_label(label, warn=false)
+        if !label
+            return false
+        elsif @consumed_labels.include?(label)
+            log(['Duplicate label'], label, :error) if warn
+            return false
+        else
+            @consumed_labels << label
+            return true
+        end
+    end
+    
     def use_id(args, opts={}, set=true)
         if args
             set &&= !args[:id]
@@ -841,24 +1150,17 @@ class Deplate::Formatter
 
     def format_indent(level, shift=false)
         if level < 0
-            log(["Negative indentation level", level], :error)
-            return ""
+            log(['Negative indentation level', level], :error)
+            return ''
         else
             l = level * 2
             # l += 1 if shift
-            return "  " * l
+            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"]
+        kw = @deplate.variables['keywords']
         if kw.kind_of?(Array)
             kw
         elsif kw.kind_of?(String)
@@ -873,11 +1175,16 @@ class Deplate::Formatter
     # 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("|"))
+        @plain_text_rx = Regexp.new('(%s)' % @special_symbols.keys.collect {|x| Regexp.escape(x)}.join('|'))
     end
     
 
     ################################################ Bibliography {{{1
+    def bib_styler
+        style = @deplate.variables['bibStyle']
+        @deplate.bib_styler(style)
+    end
+    
     def simple_bibtex_reader(bibfiles)
         acc = []
         for b in bibfiles
@@ -890,11 +1197,22 @@ class Deplate::Formatter
             end
             File.open(b) {|io| acc << io.read}
         end
-        acc = acc.join("\n")
+        strings = {}
+        acc     = acc.join("\n")
         loop do
-            m = /^\s*(@\w+\{\s*(\S+?)\s*,.*?)(?=(^@|\z))/m.match(acc)
+            m = /^\s*@string\{\s*(\S+?)\s*=\s*(.+?)\s*\}/m.match(acc)
+            if m
+                r = m[2]
+                if r =~ /^(".*?"|'.*?'|\{.*?\})$/
+                    r = r[1..-2]
+                end
+                strings[m[1]] = r
+                acc = m.post_match
+                next
+            end
+            m = /^\s*(@(\w+)\{\s*(\S+?)\s*,.*?)(?=(^@|\z))/m.match(acc)
             if m
-                id = m[2]
+                id = m[3]
                 e  = m[1]
                 arr = e.scan(/^\s*(\w+)\s*=\s*(\{.*?\}|\d+)\s*[,}]\s*$/m)
                 arr.collect! do |var, val, rest|
@@ -902,9 +1220,12 @@ class Deplate::Formatter
                     if n
                         val = n[1]
                     end
+                    if strings[val]
+                        val = strings[val]
+                    end
                     [var, val]
                 end
-                arr << ["type", m[2]]
+                arr << ['@type', m[2]] << ['@id', id]
                 @bibentries[id] = arr
                 acc = m.post_match
             else
@@ -921,7 +1242,7 @@ class Deplate::Formatter
         acc  = []
         for k in cited_keys
             b  = bib_entry(k)
-            bb = format_bib_entry(invoker, b)
+            bb = format_bib_entry(invoker, k, b)
             i  = encode_id(k)
             l  = format_label(invoker, :string, [i])
             if block_given?
@@ -934,47 +1255,15 @@ class Deplate::Formatter
         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"
+
+    def format_bib_entry(invoker, key, bibdef)
+        if bibdef.empty?
+            # text = "#{key}??? (#{@deplate.msg('Unknown bib entry')})"
+            text = "#{key}???"
         else
-            hi = "title"
+            text = bib_styler.bib_format(bibdef)
         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(". ") + ".")
+        return @deplate.parse_and_format_without_wikinames(invoker, text)
     end
 
     def simple_latex_reformat(text)
@@ -989,105 +1278,76 @@ class Deplate::Formatter
         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 = []
+            list_tags = {
+                :levels   => [],
+                :types    => [],
+                :end_tags => []
+            }
             accum    = []
             # level0  = list.sort {|a,b| a.level <=> b.level}[0].level
-            level0   = list.min {|a,b| a.level <=> b.level}.level
+            level0   = list.min do |a,b|
+                if a.level and b.level
+                    a.level <=> b.level
+                elsif a
+                    1
+                else
+                    -1
+                end
+            end.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)
+                s = list_subtype(t, i)
                 c = [i.listtype, s]
                 l = i.level
-                if last_listtype
+                if last_listtype(list_tags)
+                    special = ['Paragraph', 'Container'].include?(t)
                     # there is a list environment, so this isn't the first item
-                    if last_level and l != last_level
-                        if l < last_level
+                    if last_level(list_tags) and l != last_level(list_tags)
+                        if l < last_level(list_tags)
                             # close a nested list
-                            ind = printable_close_lists_until(invoker, accum, ind, l)
-                        elsif l > last_level and t != "Paragraph"
+                            ind = printable_close_lists_until(invoker, list_tags, accum, ind, l)
+                        elsif l > last_level(list_tags) and !special
                             # open a new nested list
-                            # p "DBG           --- 1054: #{c} != #{last_listtype}"
-                            ind = printable_open_list(invoker, accum, c, ind, l, s)
-                            @endTags << nil
+                            # p "DBG           --- 1054: #{c} != #{last_listtype(list_tags)}"
+                            ind = printable_open_list(invoker, list_tags, accum, c, ind, l, s)
+                            list_tags[:end_tags] << nil
                         end
                     end
-                    if last_level and last_listtype and c != last_listtype and t != "Paragraph"
-                        if l <= last_level
+                    if last_level(list_tags) and last_listtype(list_tags) and c != last_listtype(list_tags) and !special
+                        if l <= last_level(list_tags)
                             # close the previous list and start a new one
-                            ind = printable_list_close_endtag(invoker, accum, ind)
-                            # p "DBG             ---- #{last_listtype} #{t}"
+                            ind = printable_list_close_endtag(invoker, list_tags, accum, ind)
+                            # p "DBG             ---- #{last_listtype(list_tags)} #{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
+                        if c != last_listtype(list_tags) and l <= last_level(list_tags)
+                            # p "DBG           --- 1067: #{c} != #{last_listtype(list_tags)}"
+                            ind = printable_close_list(invoker, list_tags, accum, ind)
+                            ind = printable_open_list(invoker, list_tags, accum, c, ind, l, s)
+                            list_tags[:end_tags] << nil
                         end
                     end
                 else
                     # start a new list
-                    ind = printable_open_list(invoker, accum, c, ind, l, s)
+                    ind = printable_open_list(invoker, list_tags, accum, c, ind, l, s)
                 end
-                if @levels.empty? and idx < max
+                if list_tags[: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
+                    invoker.log(['Malformed list hierarchy', last_listtype(list_tags), idx], :error)
+                    ind = printable_open_list(invoker, list_tags, accum, c, ind, l, s)
                 end
+                ind = printable_list_item(invoker, list_tags, accum, t, ind, l, i)
                 if i.label and !i.label.empty?
                     lab = format_label(invoker, :string, i.label)
                     if lab
@@ -1097,100 +1357,135 @@ class Deplate::Formatter
             end
             
             # close all open tags & lists
-            while !@endTags.empty?
-                ind = printable_list_close_endtag(invoker, accum, ind)
+            while !list_tags[:end_tags].empty?
+                ind = printable_list_close_endtag(invoker, list_tags, accum, ind)
             end
-            while !@levels.empty?
-                ind = printable_close_list(invoker, accum, ind)
+            while !list_tags[:levels].empty?
+                ind = printable_close_list(invoker, list_tags, accum, ind)
             end
             if ind < 0
-                invoker.log("Malformed list or internal error", :error)
+                invoker.log(['Malformed list or internal error', invoker.class], :error)
             end
 
             accum.delete_if {|e| e == :empty}
-            return accum.join("\n")
+            return join_blocks(accum)
         else
-            return ""
+            return ''
         end
     end
 
-    def last_level
-        @levels.last
+    def last_level(list_tags)
+        list_tags[:levels].last
     end
 
-    def last_listtype
-        @types.last
+    def last_listtype(list_tags)
+        list_tags[: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]\.?$/
+        when "Ordered"
+            if item.item =~ /^[A-Z]\.?$/
                 return "A"
-            elsif item =~ /^[a-z?@]\.?$/
+            elsif item.item =~ /^[a-z?@]\.?$/
                 return "a"
             else
                 return "1"
             end
-        when "Itemize"
-            return nil
-        when "Description"
-            return nil
-        when "Paragraph"
-            return nil
+        # when "Itemize"
+        #     return nil
+        # when "Description"
+        #     return nil
+        # when 'Task'
+        #     return nil
+        # when "Paragraph"
+        #     return nil
+        # when 'Container'
+        #     return nil
         else
-            raise "Unknown list type: #{type}"
+            if item.opts and item.opts[:subtype]
+                return item.opts[:subtype]
+            else
+                return nil
+            end
+            # raise "Unknown list type: #{type}"
         end
     end
 
-    def printable_close_lists_until(invoker, accum, ind, level)
+    def printable_list_item(invoker, list_tags, accum, type, indentation, level, item)
+        case type
+        when 'Paragraph'
+            args = {}
+            if @list_last_type == 'Container'
+                args[:follow_container] = true
+            end
+            acc, etag = format_list_item(invoker, type, indentation, item, args)
+            accum << acc
+        when 'Container'
+            item_copy  = item.dup
+            # idt       = item_copy.body.indentation
+            # idt_level = item_copy.body.indentation_level
+            idt_mode   = invoker.args['indentation']
+            if item_copy.body
+                idt_mode ||= item_copy.body.class.indentation_mode.to_s
+                item_copy.body = item_copy.body.format_current
+            end
+            case idt_mode
+            when 'auto'
+                item_copy.body = indent_text(item_copy.body, :mult => indentation)
+            when 'none'
+            else
+                invoker.log(['Unknown indentation mode', idt_mode], :error)
+            end
+            # p "DBG #{' ' * level} Container (#{list_tags[:types]} #{@list_levels})"
+            acc, etag = format_list_item(invoker, type, indentation, item_copy)
+            accum << acc
+        else
+            indentation = printable_list_close_endtag(invoker, list_tags, accum, indentation)
+            # p "DBG #{' ' * level} Item (#{list_tags[:types]} #{@list_levels})"
+            acc, etag = format_list_item(invoker, type, indentation, item)
+            list_tags[:end_tags] << [etag, level, indentation]
+            accum << acc
+            indentation += 1
+        end
+        @list_last_type = type
+        indentation
+    end
+    
+    def printable_close_lists_until(invoker, list_tags, 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 = printable_list_close_endtag(invoker, list_tags, accum, ind)
+            ind = printable_close_list(invoker, list_tags, accum, ind)
+        end until list_tags[:levels].empty? or list_tags[:levels].last <= level
         ind
     end
     
-    def printable_close_list(invoker, accum, ind)
+    def printable_close_list(invoker, list_tags, accum, ind)
         ind -= 1
-        lev  = @levels.pop
-        tp, sp = @types.pop
+        lev  = list_tags[:levels].pop
+        tp, sp = list_tags[: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)
+    def printable_open_list(invoker, list_tags, 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
+        list_tags[:levels] << level
+        list_tags[: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
+    def printable_list_close_endtag(invoker, list_tags, accum, ind)
+        tag, level, ind0 = list_tags[:end_tags].pop
         if tag
-            while @levels.last and @levels.last > level
-                ind = printable_close_list(invoker, accum, ind)
+            while list_tags[:levels].last and list_tags[:levels].last > level
+                ind = printable_close_list(invoker, list_tags, accum, ind)
             end
             accum << tag unless tag == :none
         end
@@ -1206,5 +1501,22 @@ class Deplate::Formatter
             nil
         end
     end
+
+    def use_image_filename(filename, args={})
+        unless args['noGuess'] or args[:raw]
+            fext  = File.extname(filename)
+            fname = fext.empty? ? filename : filename[0..(-1 - fext.size)]
+            for sfx in image_suffixes
+                fs  = [fname, sfx].join
+                ff  = @deplate.auxiliary_filename(fs)
+                fff = @deplate.auxiliary_filename(fs, true)
+                if File.exist?(fff)
+                    return ff
+                end
+            end
+        end
+        return filename
+    end
+
 end