deplate 0.7.3

data/lib/deplate/elements.rb

@@ -0,0 +1,1355 @@
+# elements.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     26-M�r-2004.
+# @Last Change: 02-Nov-2005.
+# @Revision:    0.3718
+
+
+class Deplate::DontFormatException < Exception
+end
+
+Deplate::CaptionDef = Struct.new('DeplateCaptionDef', :elt, :args)
+
+# Deplate::Elements are text entities at line or paragraph level.
+class Deplate::Element < Deplate::BaseElement
+    @@elements = []
+
+    @@accumulate_pre  = {}
+    @@accumulate_post = {}
+    
+    #### attached labels
+    attr_accessor :label
+    #### an attached caption (for Table etc.)
+    attr_accessor :caption, :captionOptions
+    #### is this element in one-line format?
+    attr_accessor :multiliner
+    #### end pattern
+    attr_reader :endRx
+    #### the element's level of indentation or whatever
+    attr_accessor :level_heading, :top_heading_idx
+    #### an array of deferred formatting blocks
+    attr_accessor :postponed_format, :postponed_preformat
+    #### whether we can collapse this element with another one
+    attr_accessor :collapse
+    #### postponed registration of metadata
+    attr_accessor :registered_metadata
+    
+    attr_reader :line_cont
+
+    # class methods & variables
+    class << self
+        # the regular expression for this class
+        attr_reader :rx
+        attr_reader :labelling
+
+        def match(text)
+            return @rx.match(text)
+        end
+
+        def elements
+            return @@elements
+        end
+
+        def is_volatile?(match)
+            false
+        end
+     
+        def register_element(c=self)
+            @@elements << c
+        end
+
+        def set_labelling(val=true)
+            @labelling = val
+        end
+ 
+        def set_name(name)
+            @name=name
+        end
+        
+        def accumulate(src, array, deplate, text, match, *args)
+            Deplate::Core.log(["New element", self.name, text], :debug)
+            e = self.new(deplate, src, text, match, *args)
+            if e
+                array << e
+            end
+        end
+    
+        def accumulate_pre(klass, format, &block)
+            hooks = @@accumulate_pre[klass] || {}
+            pre   = hooks[format] || []
+            hooks[format] = pre << block
+            @@accumulate_pre[klass] = hooks
+        end
+
+        def accumulate_post(klass, format, &block)
+            hooks = @@accumulate_post[klass] || {}
+            post  = hooks[format] || []
+            hooks[format] = post << block
+            @@accumulate_post[klass] = hooks
+        end
+
+        def do_accumulate(src, array, deplate, *args)
+            run_accumulation_hooks(@@accumulate_pre[self], src, array, deplate, *args)
+            accumulate(src, array, deplate, *args)
+            run_accumulation_hooks(@@accumulate_post[self], src, array, deplate, *args)
+        end
+
+        def run_accumulation_hooks(all_hooks, src, array, deplate, *args)
+            if all_hooks
+                klass = deplate.formatter.class
+                begin
+                    hooks = all_hooks[klass]
+                    if hooks
+                        for block in hooks
+                            block.call(src, array, deplate, *args)
+                        end
+                    end
+                    klass = klass.superclass
+                end until klass === Module
+            end
+        end
+        
+        def get_date(arg, args)
+            case arg
+            when "now"
+                return Time.new.asctime
+            when "time"
+                return Time.new.strftime("%X")
+            when "today"
+                return Time.new.strftime("%d. %b %Y")
+            when "month"
+                return Time.new.strftime("%B %Y")
+            when "year"
+                return Time.new.strftime("%Y")
+            when "", nil
+                return ""
+            else
+                return Time.new.strftime(arg)
+            end
+        end
+    end
+
+    def initialize(deplate, src, text, match, *args)
+        super(deplate)
+        @source      = src
+        @text        = text
+        @match       = match
+        @endRx       = nil
+        @fmx         = nil
+        @label       = []
+        @collapse    = nil
+        @caption     = nil
+        @container   = nil
+        @line_cont   = true
+        @postponed_format    = []
+        @postponed_preformat = []
+        @registered_metadata = []
+
+        set_instance_top
+
+        @deplate.call_methods_matching(self, /^hook_pre_setup_/)
+        setup(*args)
+        @deplate.call_methods_matching(self, /^hook_post_setup_/)
+    end
+
+    def set_instance_top
+        @top_heading_idx     = @deplate.top_heading_idx
+        @top_heading         = @deplate.top_heading_by_idx(@top_heading_idx)
+        @level_heading       = @deplate.current_heading.dup
+        self.level_as_string = @deplate.get_current_heading
+    end
+
+    def setup
+    end
+
+    def level_as_string
+        @level_as_string
+    end
+    
+    def level_as_string=(val)
+        @args[:level_as_string] = val
+        @level_as_string = val
+    end
+   
+    def put_label(lab, anyway=false)
+        if lab
+            for l in lab.compact
+                # or @deplate.label_aliases.include?(l)
+                unless @label.include?(l)
+                    @label << l
+                    @deplate.add_label(self, l, @level_as_string, :anyway => anyway)
+                end
+            end
+        end
+    end
+    
+    def collapsable?(other)
+        return @collapse && other.collapse && self.class == other.class
+    end
+   
+    def drop?
+        return @collapse == :drop
+    end
+    
+    def unify(other)
+        if other.drop?
+            other.container = self
+            return true
+        elsif collapsable?(other)
+            unify_now(other)
+            other.container = self
+            return true
+        else
+            return false
+        end
+    end
+
+    def <<(line)
+        @accum << line
+    end
+
+    def to_be_continued?(line)
+        return @multiliner
+    end
+    
+    # compile the accumulated lines in @accum & put the result into @elt
+    def finish
+        elt  = join_lines(@accum)
+        @elt = [ @deplate.parse(self, elt) ]
+        return self
+    end
+
+    def finished?
+        return defined?(@elt) && @elt != nil
+    end
+
+    def join_lines(accum)
+        if @deplate.options.keep_whitespace
+            return accum.join("\n")
+        else
+            return accum.join(" ")
+        end
+    end
+
+    def process
+        process_etc
+        process_particles do |e|
+            if e.kind_of?(String)
+                ### <+TBD+> This actually is more of an error and shouldn't be
+                e
+            else
+                rv = e.collect do |p|
+                    # <+TBD+> begin
+                    # p.container = self
+                    p.process
+                    # rescue Exception => e
+                        # puts e.backtrace.join("\n")
+                        # raise
+                    # end
+                    p.elt
+                end
+                @deplate.join_particles(rv)
+            end
+        end
+        return self
+    end
+
+    def print
+        unless @args['swallow']
+            for block in @postponed_preformat
+                block.call(self)
+            end
+            output(format_current)
+            for block in @postponed_format
+                block.call(self)
+            end
+        end
+    end
+
+    def format_current(formatting_method=nil)
+        formatting_method ||= self.class.formatter
+        if formatting_method
+            elt = format_element(formatting_method, self)
+        elsif self.respond_to?(:format_special)
+            elt = format_special
+        else
+            elt = @deplate.formatter.format_unknown(self)
+        end
+        if elt
+            acc = []
+            acc << format_prologue
+            acc << elt
+            acc << format_epilogue
+            label_accum(acc, formatting_method) if doc_type == :body
+            rv = @deplate.formatter.join_blocks(acc.compact)
+        else
+            rv = nil
+        end
+        register_metadata
+        return rv
+        # rescue Exception => e
+        #     log(["Formatting failed", self.class.name, e], :error)
+        #     format_element(:format_unknown, self)
+        # end
+    end
+   
+    def register_metadata
+        @deplate.output.merge_metadata(@registered_metadata)
+        for l in @label
+            m = @deplate.get_metadata(@source, 
+                                      'type' => 'label', 
+                                      'name' => l
+                                     )
+            @deplate.output.push_metadata(m)
+        end
+    end
+
+    def label_accum(out, formatting_method)
+        fmt = @deplate.formatter
+        if fmt.label_once.include?(formatting_method)
+            l = format_element(:format_label, self, :once)
+            out.unshift(l) unless l.empty?
+        elsif fmt.label_delegate.include?(formatting_method)
+        else
+            case label_mode || fmt.label_mode
+            when :once
+                l = format_element(:format_label, self, :once)
+                out.unshift(l) unless l.empty?
+            when :before
+                l = format_element(:format_label, self, :before)
+                out.unshift(l) unless l.empty?
+            when :after
+                l = format_element(:format_label, self, :after)
+                out.push(l) unless l.empty?
+            when :delegate, :self
+            else
+                lb = format_element(:format_label, self, :before)
+                la = format_element(:format_label, self, :after)
+                out.unshift(lb) unless lb.empty?
+                out.push(la) unless la.empty?
+            end
+        end
+    end
+    
+    def format_prologue
+        @prologue.empty? ? nil : @prologue
+    end
+
+    def format_epilogue
+        @epilogue.empty? ? nil : @epilogue
+    end
+
+    def destination
+        if @top_heading and @top_heading != self
+            @top_heading.destination
+        else
+            @destination
+        end
+    end
+  
+    def register_caption
+        log(["Can't attach caption to", self.class.name], :error)
+    end
+
+    def to_plain_text
+        @accum.join("\n")
+    end
+    
+    protected
+    def process_etc
+        if !@caption and @args["caption"]
+            caption  = @deplate.parse(self, @args["caption"])
+            @caption = Deplate::CaptionDef.new(caption, @args)
+        end
+        if defined?(@caption) && @caption
+            elt = @caption.elt.collect {|p| p.process; p.elt}
+            @caption.elt = @deplate.join_particles(elt)
+        end
+    end
+    alias process_options process_etc
+
+    def unify_now(other)
+        unify_elt(other)
+        unify_props(other)
+    end
+
+    def unify_props(other)
+        put_label(other.label, true)
+        @args.update(other.args)
+        @level          ||= other.level
+        @caption        ||= other.caption
+        @captionOptions ||= other.captionOptions
+        @source.begin   ||= other.source.begin
+        @source.end       = other.source.end if other.source.end
+        if other.styles
+            update_styles(other.styles)
+        end
+        if !level_as_string and other.level_as_string
+            self.level_as_string = other.level_as_string
+        end
+    end
+    
+    def unify_elt(other)
+        if @elt.nil?
+            @elt = other.elt
+        elsif !other.elt.nil?
+            @elt += other.elt
+        end
+    end
+
+    def container=(element)
+        @container = element
+        @args      = element.args
+        @postponed_format    = element.postponed_format
+        @postponed_preformat = element.postponed_preformat
+    end
+
+    def get_indent(text)
+        text = expand_tab(text)
+        /^\s*/.match(text)[0]
+    end
+
+    def expand_tab(text)
+        tabwidth = @deplate.variables['tabwidth'] || 4
+        accum    = []
+        loop do
+            m = /\t/.match(text)
+            if m
+                pre  = m.pre_match
+                text = m.post_match
+                add  = tabwidth - pre.size % tabwidth
+                accum << pre + (" " * add)
+            else
+                return accum.join + text
+            end
+        end
+        return text
+    end
+  
+    # call block on all text particles in the current element
+    def process_particles(&block)
+        if @elt
+            @elt = (@elt.collect(&block)).join
+        else
+            log(["Internal error: no @elt", self.class], :error)
+            @elt = ""
+        end
+    end
+    alias process_elements process_particles
+
+    def register_figure
+        @deplate.table_of_figures << self
+        @deplate.current_figure += 1
+        @level_as_string = [@deplate.current_heading[0], @deplate.current_figure].join(".")
+        @label << @deplate.elt_label("fig", @level_as_string)
+    end
+    
+    def register_table
+        @deplate.table_of_tables << self
+        @deplate.current_table += 1
+        @level_as_string = [@deplate.current_heading[0], @deplate.current_table].join(".")
+        @label << @deplate.elt_label("tab", @level_as_string)
+    end
+end
+
+class Deplate::Element::Comment < Deplate::Element
+    register_element
+    set_rx(/^\s*(%+)[ \t]*(.*)$/)
+
+    # disappear
+    def self.accumulate(src, array, deplate, text, match)
+        Deplate::Core.log(["Hide comment", text], :debug)
+    end
+
+    def setup
+        @multiliner = false
+        @collapse   = true
+        @level      = get_level
+        @accum      = [get_text]
+    end
+
+    def get_level
+        @match[1].size
+    end
+
+    def get_text
+        @match[2]
+    end
+end
+
+class Deplate::Element::Region < Deplate::Element
+    register_element
+    set_rx(/^(\s*)#([A-Z]([a-z][A-Za-z]*)?)\b(.*)(\<\<(.+)|:)\s*$/)
+    @rxi_name   = 2
+    @rxi_args   = 4
+    @rxi_endrx  = 6
+    @rxi_indent = 1
+
+    attr_reader :specified, :regNote, :name
+
+    class << self
+        attr_reader :rxi_name, :rxi_args, :rxi_endrx, :rxi_indent
+
+        def pseudo_match(args)
+            [
+                nil,
+                args[:indent],  #1
+                args[:name],    #2
+                nil,            #3
+                args[:args],    #4
+                nil,            #5
+                args[:endrx],   #6
+            ]
+        end
+    end
+    
+    def setup(name=nil)
+        @multiliner = true
+        @endRx      = get_endrx
+        @accum      = []
+        @name       = name || get_name
+        begin
+            @args, @regNote = @deplate.input.parse_args(get_args)
+            @collapse       = false
+            region = @deplate.input.regions[@name]
+            unless region
+                if @deplate.formatter.matches?(@name)
+                    Deplate::Core.log(["Obsolete use of native regions. Please use", "#Native fmt=#{@deplate.formatter.formatter_name}"], :error, @source)
+                else
+                    # We put a message to notify the user of an ignored class
+                    # This should be a native class for an unused formatter
+                    Deplate::Core.log(["Unknown region class", @name], :error, @source)
+                end
+                region = Deplate::Regions::UNKNOWN
+            end
+        rescue Deplate::DontFormatException
+            Deplate::Core.log(["Dropping", @match[0]], nil, @source)
+            region = Deplate::Regions::UNKNOWN
+        end
+        @specified = region.new(@deplate, @source, @text, @match, self)
+        @specified.indent = get_indent
+        @line_cont = region.line_cont
+        # @deplate.register_id(@args, @specified)
+        @deplate.register_id(@args, self)
+    end
+
+    def get_name
+        @match[self.class.rxi_name]
+    end
+
+    def get_args
+        @match[self.class.rxi_args]
+    end
+    
+    def get_endrx
+        i = self.class.rxi_endrx
+        if @match[i - 1] == ":"
+            /^(#{get_indent})?#End\s*$/
+        else
+            erx = @match[i]
+            if erx
+                /^(#{get_indent})?#{Regexp.escape(erx)}\s*$/
+            end
+        end
+    end
+
+    def get_indent
+        @match[self.class.rxi_indent]
+    end
+    
+    def finish
+        return @specified.finish
+    end
+end
+
+class Deplate::Element::Clip < Deplate::BaseElement
+    attr_reader :is_template
+    # attr_accessor :prototype
+
+    def initialize(acc, deplate, source)
+        super(deplate)
+        @acc         = acc
+        @elt         = nil
+        @source      = source
+        @invoker     = nil
+        @is_template = false
+        @prototype   = nil
+    end
+
+    def process
+        unless @prototype
+            @prototype = @acc.first
+            @prototype.args.update(@args) if @prototype
+        end
+        unless @elt
+            @elt = @acc.collect{|p| p.process; p.elt}
+            @elt = @deplate.join_particles(@elt)
+        end
+        return self
+    end
+   
+    def format_clip(invoker, expected)
+        unless @elt
+            log("We shouldn't be here. If you can track down when this happens, please send an example to the author.", :anyway)
+            process
+        end
+        if @elt
+            @prototype.match_expected(expected, invoker)
+        else
+            log("Clip is nil, which is quite strange and most likely deplate's error but as I haven't had the time yet to track this down this error still occurs.", :error)
+        end
+        @elt
+    end
+    
+    def print
+        output(@elt)
+    end
+end
+
+class Deplate::Element::Command < Deplate::Element
+    register_element
+    set_rx /^\s*#([A-Z]+)((\s[^:]+)?(:\s*(.+?)\s*)?)$/
+    attr :name
+   
+    class << self
+        def is_volatile?(match)
+            case match[1]
+            when "IDX", "NOIDX", "DONTIDX", "AUTOIDX", "DOC", "OPT", "AUTHOR", 
+                "TITLE", "DATE", "ABBREV"
+                true
+            else
+                false
+            end
+        end
+        
+        def accumulate(src, array, deplate, text, match)
+            cmd = match[1]
+            Deplate::Core.log(["Command", cmd, text], :debug)
+            begin
+                args, text = deplate.input.parse_args(match[2])
+                case cmd
+                when "IF"
+                    deplate.switches << !check_switch(deplate, text)
+                when "ELSEIF"
+                    if deplate.switches.empty?
+                        Deplate::Core.log(["ELSEIF without IF", cmd, match[0]], :error, src)
+                    else
+                        case deplate.switches.last
+                        when :skip
+                        when true
+                            deplate.switches.pop
+                            deplate.switches << !check_switch(deplate, text)
+                        else
+                            deplate.switches.pop
+                            deplate.switches << :skip
+                        end
+                    end
+                when "ELSE"
+                    if deplate.switches.empty?
+                        Deplate::Core.log(["ELSE without IF", cmd, match[0]], :error, src)
+                    else
+                        case deplate.switches.last
+                        when :skip
+                        when true
+                            deplate.switches << !deplate.switches.pop
+                        else
+                            deplate.switches.pop
+                            deplate.switches << :skip
+                        end
+                    end
+                when "ENDIF"
+                    if deplate.switches.empty?
+                        Deplate::Core.log(["ENDIF without IF", cmd, match[0]], :error, src)
+                    else
+                        deplate.switches.pop
+                    end
+                else
+                    if !deplate.switches.last
+                        cc = deplate.input.commands[cmd]
+                        if cc
+                            cc.do_accumulate(src, array, deplate, text, match, args, cmd)
+                        else
+                            Deplate::Core.log(["Unknown command", cmd, match[0]], :error, src)
+                        end
+                    end
+                end
+            rescue Deplate::DontFormatException
+                Deplate::Core.log(["Dropping", match[0]], nil, src)
+            end
+        end
+
+        # return true if the test succeeds
+        def check_switch(deplate, text)
+            if text =~ /^\(.*\)$/
+                text = text[1..-2]
+            end
+            m = /^\s*([:]?\w+)\s*((!=~|=~|==|!=)\s*(.+)\s*|!)$/.match(text)
+            if m
+                var = m[1]
+                negate = /^no([A-Z].*)$/.match(var)
+                if negate
+                    var = negate[1][0..0].downcase + negate[1][1..-1]
+                end
+                val = m[4]
+                op  = val ? m[3] : m[2]
+                if op == "!"
+                    return get_var_or_option(deplate, var)
+                else
+                    case op
+                    when "==", "!="
+                        compare = Proc.new {|a, b| a == b}
+                    when "=~", "!=~"
+                        compare = Proc.new {|a, b| a =~ Regexp.new(b)}
+                    else
+                        raise "Internal error"
+                    end
+                    case var
+                    when "fmt"
+                        switch = compare.call(deplate.formatter.formatter_name, val)
+                    else
+                        switch = compare.call(get_var_or_option(deplate, var), val)
+                    end
+                    if op[0..0] == "!" or negate
+                        return !switch
+                    else
+                        return switch
+                    end
+                end
+            elsif text =~ /^\w+$/
+                return get_var_or_option(deplate, text)
+            else
+                Deplate::Core.log(["Malformed condition", text], :error)
+                return true
+            end
+        end
+
+        def get_var_or_option(deplate, key)
+            if deplate.variables.has_key?(key)
+                return deplate.variables[key]
+            elsif deplate.options.allow.include?(':') && key =~ /^:(.*)$/
+                return deplate.options.send($1)
+            end
+            Deplate::Core.log(["Unknown variable or option", key])
+            return nil
+        end
+    end
+end
+
+class Deplate::Element::Note < Deplate::Element
+    register_element
+    set_formatter :format_note
+    set_rx /^([ \t]+)([#!?+]{3,3})\s+(.*)$/
+
+    attr_reader :marker
+
+    def setup
+        @multiliner   = true
+        @collapse     = false
+        @level        = get_level
+        @marker       = get_marker
+        @accum        = [get_text]
+    end
+    
+    def to_be_continued?(line)
+        indent = get_indent(line).size
+        return indent >= @level
+    end
+
+    def get_level
+        expand_tab(@match[1]).size
+    end
+
+    def get_marker
+        @match[2][0..0]
+    end
+
+    def get_text
+        @match[3]
+    end
+end
+
+Deplate::ListItem   = Struct.new("DeplateListItem", :item, :body, :listtype, :type,
+                                 :level, :max, :explicit, :label, :style)
+
+class Deplate::List < Deplate::Element
+    set_formatter :format_list
+    set_labelling
+    
+    attr_reader :levelRange, :item, :oitem
+    
+    class << self
+        attr :name
+    end
+    
+    def setup
+        @multiliner = true
+        @collapse   = true
+        @level      = get_level
+        if self.instance_of?(Deplate::List::Description)
+            @levelMax = @level + (@deplate.variables["tabwidth"] || 4)
+        else
+            @levelMax = get_level_max
+        end
+        @oitem = @item = get_item
+        @accum = [get_text]
+    end
+
+    def get_level
+        expand_tab(@match[2]).size
+    end
+
+    def get_level_max
+        expand_tab(@match[1]).size
+    end
+
+    def get_item
+        @match[3]
+    end
+
+    def get_text
+        @match[4]
+    end
+
+    def collapsable?(other)
+        if other.kind_of?(Deplate::List)
+            return true
+        elsif other.kind_of?(Deplate::Element::Paragraph)
+            return @elt.find do |i|
+                continuation_level_ok?(other.level, i.level, i.max)
+            end
+        elsif other.kind_of?(Deplate::Element::Whitespace)
+            return true
+        else
+            return false
+        end
+    end
+
+    def unify_now(other)
+        if other.kind_of?(Deplate::Element::Paragraph)
+            @elt << Deplate::ListItem.new([], other.elt.flatten, @elt.last.listtype, 
+                                        "Paragraph", other.level, other.level, 
+                                         other.is_explicit?, other.label)
+            other.label = []
+            unify_props(other)
+        elsif other.kind_of?(Deplate::Element::Whitespace)
+        else
+            super
+        end
+    end
+
+    def to_be_continued?(line)
+        linelevel = get_indent(line).size
+        return continuation_level_ok?(linelevel, @level, @levelMax)
+    end
+
+    def continuation_level_ok?(otherLevel, thisLevel, thisMaxLevel)
+        # return thisLevel <= otherLevel && otherLevel <= thisMaxLevel
+        return thisLevel <= otherLevel
+    end
+    
+    def finish
+        @item  = @deplate.parse(self, @item)
+        accum  = @deplate.parse(self, @accum.join(" "))
+        name   = self.class.name
+        @elt   = [Deplate::ListItem.new(@item, accum, name, name, @level, 
+                                        @levelMax, is_explicit?, @label)]
+        @label = []
+        return self
+    end
+
+    def process_particles(&block)
+        @elt.each do |e|
+            e.item = block.call(e.item)
+            e.body = block.call(e.body)
+        end
+    end
+end
+
+class Deplate::List::Numbered < Deplate::List
+    register_element
+    set_formatter :format_list
+    set_rx /^(([ \t]+)([0-9]+\.|[#\@?]\.?|[a-zA-Z?]\.)[ \t]+)(.+)$/
+    set_name "Numbered"
+    
+    def is_explicit?
+        if @oitem =~ /^[0-9a-zA-Z]+\.$/
+            return true
+        else
+            return false
+        end
+    end
+end
+
+class Deplate::List::Itemize < Deplate::List
+    register_element
+    set_formatter :format_list
+    set_rx /^(([ \t]+)([-�+*])[ \t]+)(.+)$/
+    set_name "Itemize"
+end
+
+class Deplate::List::Description < Deplate::List
+    register_element
+    set_formatter :format_list
+    set_rx /^(([ \t]+)(.+?)[ \t]+::[ \t])(.*)$/
+    set_name "Description"
+end
+
+
+
+class Deplate::Element::Table < Deplate::Element
+    register_element
+    set_formatter :format_table
+    set_rx /^(\|\|?)([ \t]+.+[ \t]+)\1$/
+
+    TableRow  = Struct.new("DeplateTableRow", :high, :cols, :head, :foot, :is_ruler,
+                           :from_top, :from_bottom)
+    TableCell = Struct.new("DeplateTableCell", :cell, 
+                           :x, :y, :from_right, :from_bottom,
+                           :high, :head, :foot,
+                           :span_x, :span_y, :row)
+
+    attr_accessor :preNote, :postNote, :coordinates, 
+        :contains_footnotes, :printed_header
+
+    def setup
+        @multiliner  = false
+        @collapse    = true
+        high         = get_highlight
+        cols         = get_cols
+        cols.collect! {|t| t.strip}
+        @accum       = [ TableRow.new(high, cols) ]
+        @preNote     = nil
+        @postNote    = nil
+        @contains_footnotes = false
+    end
+
+    def get_highlight
+        @match[1].size == 2
+    end
+
+    def get_cols
+        @match[2].split(/[ \t]\|\|?[ \t]/)
+    end
+    
+    def unify_now(other)
+        super
+        @contains_footnotes ||= other.contains_footnotes
+    end
+    
+    def collapsable?(other)
+        return @collapse && other.collapse && self.class == other.class
+    end
+   
+    def finish
+        @accum.each do |row|
+            row.is_ruler = false
+            row.cols.collect! do |c|
+                case c
+                when /^-+$/
+                    row.is_ruler = true
+                    :ruler
+                when "<"
+                    log(["Malformed ruler definition (<)", col.cols], :error) if row.is_ruler
+                    :join_left
+                when "^"
+                    log(["Malformed ruler definition (^)", col.cols], :error) if row.is_ruler
+                    :join_above
+                when /^\s*$/
+                    if row.is_ruler
+                        :noruler
+                    else
+                        @deplate.parse(self, c)
+                    end
+                else
+                    log(["Malformed ruler definition", c, col.cols], :error) if row.is_ruler
+                    @deplate.parse(self, c)
+                end
+            end
+        end
+        @elt = @accum
+        return self
+    end
+ 
+    def process_particles(&block)
+        hiCol   = get_table_args("hiCol")
+        hiRow   = get_table_args("hiRow")
+        head    = @args["head"]
+        head    = head ? head.to_i : 0
+        foot    = @args["foot"]
+        foot    = foot ? foot.to_i : 0
+        rowmax  = @elt.size
+        @coordinates = {}
+        y = 0
+        rown = @elt.size
+        for row in @elt
+            y += 1
+            x  = 0
+            coln = row.cols.size
+            row.cols.collect! do |cell|
+                x += 1
+                case cell
+                when :join_left
+                    parent = find_parent_cell(x, y, 1, 0)
+                    if parent.kind_of?(Symbol)
+                    elsif parent
+                        parent.span_x += 1
+                    else
+                        log(["Table: Can't join with left cell", x, y], :error)
+                    end
+                when :join_above
+                    parent = find_parent_cell(x, y, 0, 1)
+                    if parent.kind_of?(Symbol)
+                    elsif parent
+                        parent.span_y += 1
+                    else
+                        log(["Table: Can't join with above cell", x, y], :error)
+                    end
+                when :ruler, :noruler
+                    row.is_ruler = true
+                else
+                    cell = TableCell.new(block.call(cell), x, y)
+                    cell.from_bottom = rown - y
+                    cell.from_right  = coln - x
+                    cell.span_x = 1
+                    cell.span_y = 1
+                    cell.row    = row
+                    cell.high   = check_table_opts(hiCol, x, coln)
+                end
+                @coordinates[[x,y]] = cell
+                cell
+            end
+            if y <= head
+                row.head = true
+            elsif (rowmax - y + 1) <= foot
+                row.foot = true
+            elsif check_table_opts(hiRow, y, rowmax)
+                row.high = true
+            end
+            row.from_top    = y
+            row.from_bottom = rowmax - y
+        end
+        for row in @elt
+            if row.high
+                row.head = true
+            else
+                break
+            end
+        end
+        for row in @elt.reverse
+            if row.high and !row.head
+                row.foot = true
+            else
+                break
+            end
+        end
+    end
+
+    def check_table_opts(args, nth, max)
+        (nth == 1 and args.include?("first")) or 
+            (nth == max and args.include?("last")) or 
+            args.include?("%d" % nth)
+    end
+    
+    def get_table_args(name)
+        args = @args[name]
+        args ? args.split(/\s*,\s*/) : []
+    end
+
+    def find_parent_cell(x, y, delta_x, delta_y)
+        i = 1
+        loop do
+            xx = x - (delta_x * i)
+            yy = y - (delta_y * i)
+            c = @coordinates[[xx, yy]]
+            case c
+            when :join_left
+                return c if delta_x == 0
+            when :join_above
+                return c if delta_y == 0
+            when :ruler, :noruler
+            when nil
+                return nil
+            else
+                return c
+            end
+            i += 1
+        end
+    end
+
+    def register_caption
+        register_table
+    end
+end
+
+class Deplate::Element::Heading < Deplate::Element
+    attr_accessor :first_top, :last_top, :top_index, :abstract
+    attr_writer :destination
+    
+    register_element
+    set_formatter :format_heading
+    set_rx /^(\*+)[ \t]+(.*?)$/
+
+    class << self
+        def accumulate(src, array, deplate, text, match)
+            Deplate::Element::PotentialPageBreak.accumulate(src, array, deplate, text, match)
+            ppb = array[-1]
+            super
+            hd  = array[-1]
+            if hd.is_top_heading?
+                ppb.enabled = true
+            end
+        end
+        
+        # Programmatically markup text as heading.
+        def markup(text, level=1)
+            ['*' * level, text].join(' ')
+        end
+    end
+    
+    def set_instance_top
+        @level = get_level
+        ls = @deplate.variables["levelshift"]
+        if ls
+             @level += ls.to_i
+        end
+        if is_top_heading?
+            @deplate.current_table  = 0
+            @deplate.current_figure = 0
+        end
+        @deplate.increase_current_heading(@level)
+        super
+    end
+    
+    def setup
+        @first_top   = false
+        @last_top    = false
+        @multiliner  = false
+        @collapse    = false
+        @abstract    = nil
+        @accum       = [get_text]
+        @args[:id]   = @deplate.elt_label("hd", @level_as_string)
+        @destination = @deplate.output.destination
+        @top_index   = [0, 0]
+        @deplate.table_of_contents << self
+        @deplate.headings[@level_heading] = self
+        update_args
+    end
+
+    def get_level
+        @match[1].size
+    end
+
+    def get_text
+        @match[2]
+    end
+
+    def is_top_heading?
+        @level == 1
+    end
+    
+    def update_options(args)
+        @args.update(args)
+        update_args
+    end
+    
+    def update_args
+        super
+        register_heading
+    end
+
+    def register_heading
+        sc = @args['id'] || @args['shortcaption']
+        log(['Register heading', level_as_string, sc], :debug)
+        @deplate.set_top_heading(self, sc)
+    end
+    
+    def process
+        rv = super
+        if rv.is_top_heading?
+            @deplate.options.heading_names[@top_heading_idx] = rv.elt
+            if @deplate.variables['subToC']
+                args  = {'sub' => true, 'plain' => true}
+                match = []
+                toc = Deplate::Command::LIST.new(@deplate, @source, 'toc', match, args, 'LIST')
+                toc.level = @level
+                toc.level_as_string = @level_as_string
+                rv = [rv, toc.finish.process].compact.flatten
+            end
+        end
+        rv
+    end
+
+    def register_metadata
+        stats = @source.stats
+        mtime = stats ? stats.mtime : nil
+        args  = {
+            'type' => 'heading',
+            'name' => description,
+            'id'   => get_id
+        }
+        if @abstract
+            args['abstract'] = @abstract.to_plain_text
+        end
+        @registered_metadata << @deplate.get_metadata(@source, args)
+        super
+    end
+    
+    def description
+        if @args['shortcaption']
+            @args['shortcaption']
+        elsif @caption
+            @caption.elt
+        else
+            @elt
+        end
+    end
+
+    def register_caption
+        @deplate.table_of_contents << self
+        @label << @deplate.elt_label('hd', @level_as_string)
+    end
+end
+
+class Deplate::Element::Break < Deplate::Element
+    register_element
+    set_formatter :format_break
+    set_rx /^\s*-{2,}8\<-{2,}\s*$/
+
+    def setup
+        @multiliner   = false
+        @collapse     = false
+        @accum        = []
+    end
+end
+
+# An anchor is not a proper element, but is attached to the preceding one
+class Deplate::Element::Anchor < Deplate::Element
+    register_element
+    set_formatter :format_anchor
+    set_rx /^\s*%?#([a-z][a-zA-Z0-9:_-]+).*$/
+
+    class << self
+        def accumulate(src, array, deplate, text, match)
+            i = 0
+            l = get_text(match)
+            Deplate::Core.log(['New anchor', l], :debug)
+            last = array.last
+            if last and last.can_be_labelled
+                last.put_label([l])
+                # last.args["label"] ||= l
+                deplate.labels_named << l
+            else
+                Deplate::Core.log(["Defer label", l], nil, src)
+                deplate.labels_floating << l
+            end
+        end
+
+        def get_text(match)
+            match[1]
+        end
+        
+        def is_volatile?(match)
+            true
+        end
+    end
+    
+    def setup
+        put_label([@text])
+    end
+
+    def process
+        return self
+    end
+end
+
+# just disappear
+class Deplate::Element::Whitespace < Deplate::Element
+    register_element
+    set_rx /^\s*$/
+
+    class << self
+        def accumulate(src, array, deplate, text, match)
+            Deplate::Core.log(["Whitespace", text], :debug)
+            le = array.last
+            kw = deplate.options.keep_whitespace
+            if le.kind_of?(Deplate::Element::Table) or (kw and !(le and le.collapse))
+                e = self.new(deplate, src, text, match, kw)
+                if e
+                    array << e
+                end
+            end
+        end
+    end
+
+    def setup(kw)
+        @multiliner = false
+        @collapse   = true
+        @accum      = [@text]
+        @can_be_labelled = false
+        @keep_whitespace = kw
+    end
+
+    def process
+        return @keep_whitespace ? self : nil
+    end
+
+    def print
+        if @keep_whitespace
+            output(@accum.join)
+        end
+    end
+    alias :format_special :print
+end
+
+
+class Deplate::Element::PotentialPageBreak < Deplate::Element
+    set_formatter :format_PAGEBREAK
+    attr_accessor :enabled
+    
+    def initialize(*args)
+        @enabled = false
+        super
+    end
+    
+    def process
+        if @enabled and @deplate.options.multi_file_output
+            self
+        else
+            nil
+        end
+    end
+end
+
+
+# Don't register Paragraph in @@elements -- it's assigned if nothing else 
+# matches
+class Deplate::Element::Paragraph < Deplate::Element
+    set_formatter :format_paragraph
+    set_rx /^([ \t]*)(.+)[ \t]*$/
+
+    class << self
+        def from_text(deplate, src, text)
+            m = @rx.match(text)
+            self.new(deplate, src, text, m)
+        end
+    end
+    
+    def setup
+        @multiliner = true
+        @collapse   = false
+        @level      = get_level
+        @accum      = [get_text]
+    end
+
+    def get_level
+        get_indent(@match[1]).size
+    end
+
+    def get_text
+        @deplate.options.keep_whitespace ? @match[0] : @match[2]
+    end
+end
+
+# vim: ff=unix