deplate 0.7.3

data/lib/deplate/fmt/php.rb

@@ -0,0 +1,19 @@
+# php.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.911
+
+require 'deplate/fmt/html'
+require 'deplate/mod/php-extra'
+
+# A variant of the html-formatter that is suited for php output.
+
+class Deplate::Formatter::Php < Deplate::Formatter::HTML
+    self.myname = "php"
+    self.rx     = /php[0-9]?/i
+    self.suffix = ".php"
+end
+

data/lib/deplate/fmt/phpsite.rb

@@ -0,0 +1,19 @@
+# phpsite.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 29-Okt-2005.
+# @Revision:    0.916
+
+require 'deplate/fmt/htmlsite'
+require 'deplate/mod/php-extra'
+
+# A variant of the htmlsite-formatter that is suited for php output.
+
+class Deplate::Formatter::PhpSite < Deplate::Formatter::HTML_Site
+    self.myname = "phpsite"
+    self.rx     = /php[0-9]?/i
+    self.suffix = ".php"
+end
+

data/lib/deplate/fmt/plain.rb

@@ -0,0 +1,598 @@
+# fmt-html.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     17-M�r-2004.
+# @Last Change: 28-Okt-2005.
+# @Revision:    0.3450
+
+require "deplate/formatter"
+
+# No formatter.
+
+class Deplate::Formatter::Plain < Deplate::Formatter
+    self.myname = "plain"
+    self.rx     = /plain/i
+    self.suffix = ".txt"
+
+    self.label_mode     = :delegate
+    self.label_delegate = []
+    self.label_once     = []
+    
+    def initialize(deplate, args)
+        super
+        @list_counter = {}
+    end
+
+    def read_bib(bibfiles)
+        simple_bibtex_reader(bibfiles)
+    end
+
+    def format_label(invoker, mode=nil, label=nil)
+        ""
+    end
+
+    def format_figure(invoker, inline=false, elt=nil)
+        if elt
+            if inline
+                elt
+            else
+                "\n#{elt}\n"
+            end
+        elsif inline
+            include_image(invoker.elt, invoker.args)
+        else
+            acc = []
+            fig     = @deplate.msg("Figure")
+            caption = invoker.caption
+            if caption
+                capAbove = !(caption && caption.args && caption.args.include?("below"))
+                lev      = invoker.level_as_string
+                cap = %{#{fig} #{lev}: #{caption.elt}}
+            else
+                capAbove = false
+            end
+            if caption and capAbove
+                acc << cap
+            end
+            acc << include_image(invoker.elt, invoker.args)
+            if caption and !capAbove
+                acc << cap
+            end
+            acc << ""
+            join_blocks(acc)
+        end
+    end
+
+    def include_image(file, args, inline=false)
+        # alt = args["alt"]
+        # alt ? "[#{alt}]" : "[IMG:#{file}]"
+        "[#{args["alt"] || file}]"
+    end
+
+    alias :format_IMG :format_figure
+
+    alias :format_MAKETITLE :format_title
+    
+    def format_note(invoker)
+        indent = "  #{invoker.marker * 3} "
+        wrap_text(indent + invoker.elt, :indent => indent) + "\n"
+    end
+
+    def format_table(invoker)
+        elt        = invoker.elt
+        args       = invoker.args
+        level_as_string = invoker.level_as_string
+        caption    = invoker.caption
+        capAbove   = !(caption && caption.args && caption.args.include?("below"))
+
+        widths = []
+        elt.each_with_index do |row, y|
+            row.cols.each_with_index do |cell, x|
+                case cell
+                when :join_left, :join_above
+                when :ruler, :noruler
+                else
+                    t = cell.cell.split(/\n/).collect {|l| l.size}
+                    s = t.max || 0
+                    w = widths[x]
+                    if !w or w < s
+                        widths[x] = s
+                    end
+                end
+            end
+        end
+
+        ruler = ["+-", widths.collect {|w| "-" * w}.join("-+-"), "-+"].join
+        acc = []
+        
+        if caption and capAbove
+            acc << %{#{@deplate.msg("Table")} #{level_as_string}: #{caption.elt}}
+        end
+        
+        acc_head = []
+        acc_foot = []
+        acc_body = []
+        elt.each_with_index do |r, n|
+            if r.is_ruler
+                # acc_body << ruler
+            elsif r.head
+                acc_head << formatted_table_row(n, r, widths)
+            elsif r.foot
+                acc_foot << formatted_table_row(n, r, widths)
+            else
+                acc_body << formatted_table_row(n, r, widths)
+            end
+        end
+
+        acc << ruler
+        unless acc_head.empty?
+            acc << acc_head << ruler
+        end
+        acc << acc_body
+        unless acc_foot.empty?
+            acc << ruler << acc_foot
+        end
+        acc << ruler
+
+        note = invoker.args["note"]
+        if note
+            acc << @deplate.parse_and_format(invoker, note)
+        end
+        
+        if caption and !capAbove
+            acc << %{#{@deplate.msg("Table")} #{level_as_string}: #{caption.elt}}
+        end
+
+        acc << ""
+        join_blocks(acc)
+    end
+    
+    def formatted_table_row(y, r, widths)
+        n   = 1
+        i   = 0
+        acc = []
+        cols = r.cols.collect do |c|
+            if c.kind_of?(Symbol)
+                c
+            else
+                c.cell.gsub(/\n*(.*)\n*/, "\\1")
+            end
+        end
+        while i < n
+            row = []
+            r.cols.each_with_index do |c, x|
+                case c
+                when :join_left
+                when :join_above
+                    w = widths[x]
+                    row << %{%-#{w}s} % " "
+                when :ruler, :noruler
+                    w = get_width(x, c.span_x, widths)
+                    row << %{%-#{w}s} % (i == 0 ? "-" : " ")
+                else
+                    w  = get_width(x, c.span_x, widths)
+                    t  = c.cell.split(/\n/)
+                    ts = t.size
+                    if ts > n
+                        n = ts
+                    end
+                    row << %{%-#{w}s} % (t[i] || " ")
+                end
+            end
+            acc << "| #{row.join(" | ")} |"
+            i += 1
+        end
+        acc.join("\n")
+    end
+    private :formatted_table_row
+   
+    def get_width(x, span, widths)
+        w = widths[x]
+        for j in 1..(span - 1)
+            w += 3 + widths[x + j]
+        end
+        w
+    end
+    private :get_width
+    
+    def format_heading(invoker, level=nil, elt=nil)
+        level ||= invoker.level
+        elt   ||= invoker.elt
+        ul      = ["", "=", "~", "-", '"', "'"][level]
+        if invoker and invoker.level_as_string
+            elt = [invoker.level_as_string, elt].join(" ")
+        end
+        if ul
+            [nil, elt, ul * elt.size, nil].join("\n")
+            # [elt, ul * elt.size].join("\n")
+        else
+            # "\n#{elt}\n"
+            elt
+        end
+    end
+
+    def format_list(invoker)
+        printable_list(invoker) + "\n"
+    end
+    
+    def format_list_env(invoker, type, level, what, subtype=nil)
+        case what
+        when :open
+            @list_counter[type] ||= []
+            @list_counter[type].push(0)
+        when :close
+            @list_counter[type].pop
+        end
+        nil
+    end
+
+    LIST_ITEMIZE_MARKERS   = ['*', '*', '+', '+', '-', '-']
+    LIST_ITEMIZE_MARKERS_N = LIST_ITEMIZE_MARKERS.size
+    # <+TBD+>Alphabethic lists give strange counters if the index passes beyond 'z'
+    def format_list_item(invoker, type, level, item, html_class=nil, explicit=false)
+        # indent = format_indent(level, true)
+        indent = "  " * level
+        case type
+        when "Numbered"
+            if explicit or item.explicit and item.item
+                # and !item.item.empty?
+                i = item.item
+            else
+                i = @list_counter[type][-1] += 1
+                case list_subtype(type, item.item)
+                when "a"
+                    i = "%c" % (96 + i)
+                when "A"
+                    i = "%c" % (64 + i)
+                else
+                    i = i.to_s
+                end
+            end
+            unless i.empty?
+                i += ". "
+            end
+            return wrap_text([indent, i, item.body].join, :hanging => 2), :none
+        when "Itemize"
+            if explicit or item.explicit and item.item
+                # and !item.item.empty?
+                i = item.item
+            else
+                i = LIST_ITEMIZE_MARKERS[level % LIST_ITEMIZE_MARKERS_N]
+            end
+            unless i.empty?
+                i += " "
+            end
+            return wrap_text([indent, i, item.body].join, :hanging => 2), :none
+        when "Description"
+            accum = [indent, item.item, "\n"]
+            accum << indent << "  " << item.body if item.body
+            return wrap_text(accum.join), :none
+        when "Paragraph"
+            # t = "\n" + wrap_text(indent + item.body)
+            t = wrap_text(indent + item.body)
+            return t, nil
+        else
+            raise "Unknown list type: #{item.inspect}"
+        end
+    end
+
+    def format_verbatim(invoker, text=nil)
+        text = invoker.elt
+        indent_text(text) + "\n"
+    end
+
+    def format_abstract(invoker)
+        text = invoker.elt
+        wrap_text("    " + text) + "\n"
+    end
+
+    def format_quote(invoker)
+        text = invoker.elt
+        wrap_text("> " + text, :indent => "> ") + "\n"
+    end
+
+    def format_title(invoker)
+        acc = []
+        for i, c in [["title",      %{%s}],
+                     ["author",     %{%s}], 
+                     ["authornote", %{%s}],
+                     ["date",       %{%s}]]
+            ii = @deplate.get_clip(i)
+            acc << wrap_text(c % ii.elt) if ii
+        end
+        acc = acc.join("\n\n")
+        s   = acc.collect {|l| l.size}.max
+        r   = "~" * s
+        [r, acc, r, nil].join("\n\n")
+    end
+
+    def format_MAKEBIB(invoker)
+        format_bibliography(invoker) do |key, labels, text|
+            wrap_text("  " + text, :hanging => 4)
+        end
+    end
+
+    def format_IDX(invoker)
+        nil
+    end
+
+    def format_emphasize(invoker, text)
+        text
+    end
+
+    def format_code(invoker, text)
+        text
+    end
+
+    # <+TBD+> [1] + urls at the bottom
+    def format_url(invoker, name, dest, anchor, literal=false)
+        idx = @deplate.footnote_last_idx += 1
+        fn = "[#{idx}]"
+        # invoker.container.postponed_format << Proc.new do |container|
+            output_at(:body, :footnotes, %{#{fn} #{Deplate::HyperLink.url_anchor(dest, anchor)}})
+        # end
+        if name and !(name.empty?)
+            [name, fn].join
+        else
+            fn
+        end
+    end
+
+    alias :format_wiki :format_url
+    # def format_wiki(invoker, name, dest, anchor)
+    #     idx = @deplate.footnote_last_idx += 1
+    #     fn = "[#{idx}]"
+    #     invoker.container.postponed_format << Proc.new do |container|
+    #         output_at(:body, :footnotes, %{#{fn} #{Deplate::HyperLink.url_anchor(dest, anchor)}})
+    #     end
+    #     [name, fn].join(" ")
+    # end
+
+    def format_symbol(invoker, text)
+        text
+    end
+
+    def format_index(invoker, idx)
+        ""
+    end
+
+    def format_footnote(invoker)
+        elt = invoker.elt
+        if elt and elt.elt and elt.elt.consumed
+            fn  = elt.elt
+            lab = fn.label
+            if !@deplate.footnotes_used.include?(lab)
+                idx      = @deplate.footnote_last_idx +=1
+                lab      = "[#{idx}]"
+                fn.n     = idx
+                fn.label = lab
+                @deplate.footnotes_used << lab
+                text     = wrap_text("#{lab} #{fn.body}", :hanging => 4)
+                # invoker.container.postponed_format << Proc.new do |container|
+                    output_at(:body, :footnotes, text)
+                # end
+            end
+        end
+        return fn.label
+    end
+
+    def format_ref(invoker)
+        " " + @deplate.labels[invoker.text]
+    end
+
+    def format_break(invoker)
+        "-" * 72
+    end
+    
+    def format_anchor(invoker)
+        ""
+    end
+    
+    def format_paragraph(invoker)
+        wrap_text(invoker.elt) + "\n"
+    end
+    
+    def format_header(invoker)
+        format_header_or_footer(invoker, :pre, :header)
+        nil
+    end
+
+    def format_footer(invoker)
+        format_header_or_footer(invoker, :post, :footer)
+        nil
+    end
+    
+    def format_header_or_footer(invoker, type, slot)
+        args = invoker.args
+        acc  = [""]
+        for e in invoker.elt
+            e.args[:dontWrapTable] = true
+            acc << e.format_current
+        end
+        acc << ""
+        output_at(type, slot, *acc)
+        nil
+    end
+    private :format_header_or_footer
+    
+    def format_pagebreak(invoker, style=nil, major=false)
+        ""
+    end
+    
+    def doublequote_open(invoker)
+        '"'
+    end
+    
+    def doublequote_close(invoker)
+        '"'
+    end
+    
+    def singlequote_open(invoker)
+        "'"
+    end
+    
+    def singlequote_close(invoker)
+        "'"
+    end
+    
+    def format_linebreak(invoker)
+        "\n"
+    end
+    
+    def format_subscript(invoker)
+        invoker.elt
+    end
+    
+    def format_superscript(invoker)
+        invoker.elt
+    end
+    
+    def format_stacked(invoker)
+        invoker.elt
+    end
+    
+    def format_pagenumber(invoker)
+        return ""
+    end
+
+    def format_list_of_contents(invoker)
+        format_list_of(invoker, "Table of Contents", @deplate.table_of_contents, "hd", 
+                       :flat => false)
+    end
+
+    alias :format_list_of_toc :format_list_of_contents
+
+    def format_list_of_minitoc(invoker)
+        data = @deplate.table_of_contents.find_all {|e| e.level == 1}
+        format_list_of(invoker, "Contents", data, "hd", 
+                       :flat => false) do |hd|
+            hd.args["shortcaption"] || hd.args["id"]
+        end
+    end
+
+    def format_list_of_tables(invoker)
+        format_list_of(invoker, "List of Tables", @deplate.table_of_tables, "tab", 
+                       :flat => true)
+    end
+
+    def format_list_of_figures(invoker)
+        format_list_of(invoker, "List of Figures", @deplate.table_of_figures, "fig", 
+                       :flat => true)
+    end
+
+    def format_list_of_index(invoker)
+        format_the_index(invoker, "Index", @deplate.index, "idx", true)
+    end
+
+    def format_list_of(invoker, name, data, prefix, other_args)
+        args = invoker.args
+        flat = other_args[:flat] || false
+        name = args["title"] || name
+        id   = name.gsub(/\W/, "_")
+        
+        acc  = []
+        unless args["plain"] || args["noTitle"]
+            acc << format_heading(nil, 1, @deplate.msg(name))
+        end
+        ll = 1
+        accData = []
+        for hd in data
+            unless hd.nil? or hd.args["noList"]
+                l = if flat then 1 else hd.level end
+                v = nil
+                if block_given?
+                    v = yield(hd)
+                end
+                unless v
+                    v = if hd.caption then hd.caption.elt else v = hd.elt.dup end
+                end
+                v = [hd.level_as_string, v].join(" ") unless hd.plain_caption?
+                s = Deplate::ListItem.new("", v, "Itemize", "Itemize", l, 0, true)
+                accData << s
+            end
+        end
+        acc << printable_list(invoker, accData) << ""
+        join_blocks(acc)
+    end
+
+    def format_the_index(invoker, name, data, prefix="", flat=false, other_args={})
+        accum  = []
+        chars  = []
+        
+        # accum << format_list_env(invoker, "Description", 0, :open)
+        for n, arr in sort_index_entries(data)
+            cht = get_first_char(n, true)
+            if !chars.include?(cht)
+                chars << cht
+                accum << format_list_env(invoker, "Description", 0, :close) unless accum.empty?
+                accum << format_heading(nil, 2, cht)
+                accum << format_list_env(invoker, "Description", 0, :open)
+            end
+            acc = []
+            for i in arr
+                ff = @deplate.dest
+                if i.file || i.level_as_string
+                    f = i.file || invoker.output_file_name(:level_as_string => i.level_as_string,
+                                                           :relative => invoker)
+                    if f == ff
+                        f = ""
+                        l = i.level_as_string
+                        if l and !l.empty?
+                            t = l
+                        elsif @deplate.options.multi_file_output
+                            t = "<>"
+                        else
+                            t = "I"
+                        end
+                    else
+                        t = @deplate.file_with_suffix(f, "", true)
+                    end
+                    acc << t
+                else
+                    log(["Index: Neither file nor level defined: dropping", i.label], :error)
+                end
+            end
+            s = Deplate::ListItem.new(plain_text(n), acc.join(", "))
+            ot, et = format_list_item(invoker, "Description", 0, s)
+            accum << ot
+            accum << et unless et == :none
+        end
+        accum << format_list_env(invoker, "Description", 0, :close)
+        acc = []
+        acc << chars.join(" ")
+        acc << accum.compact.join("\n")
+        acc << ""
+        join_blocks(acc)
+    end
+end
+
+
+class Deplate::Command::MAKEBIB
+    accumulate_pre(self, Deplate::Formatter::Plain) do |src, array, deplate, text, match, args, cmd|
+        unless args["plain"]
+            n = deplate.msg("Bibliography")
+            m = [nil, "*", n]
+            o = Deplate::Element::Heading.new(deplate, src, n, m).finish
+            o.update_options(args)
+            deplate.options.html_makebib_heading = o
+            array << o
+        end
+    end
+end
+
+
+class Deplate::Command::LIST
+    accumulate_pre(self, Deplate::Formatter::Plain) do |src, array, deplate, text, match, args, cmd|
+        if text == "index" and !args["plain"] and !args["noTitle"]
+            n = deplate.msg("Index")
+            m = [nil, "*", n]
+            h = Deplate::Element::Heading.new(deplate, src, n, m).finish
+            h.update_options(args)
+            array << h
+        end
+    end
+end
+
+
+# vim: ff=unix