deplate 0.7.3 → 0.8

data/lib/deplate/deplate-string.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# deplate-string.rb
+# @Author:      Thomas Link (samul AT web de)
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     31-Dez-2005.
+# @Last Change: 03-Jan-2006.
+# @Revision:    0.39
+
+require 'deplate/converter'
+
+class DeplateString < String
+    @deplate_options = Deplate::Core.deplate_options
+    @deplate_options.included = true
+
+    class << self
+        attr_reader :deplate_options
+    end
+
+    attr_reader :deplate_options
+    attr_reader :deplate_variables
+    attr_reader :deplate_converter
+
+    def initialize(*args)
+        @deplate_options = self.class.deplate_options.dup
+        super
+    end
+    
+    def with_deplate_options(&block)
+        block.call(@deplate_options)
+    end
+    
+    def deplate(fmt)
+        @deplate_converter = Deplate::Converter.new(fmt,
+                                     :options => @deplate_options)
+        rv = @deplate_converter.convert_string(self)
+        @deplate_variables = @deplate_converter.deplate.variables
+        rv
+    end
+    
+    def to_html
+        deplate('html')
+    end
+
+    def to_xhtml
+        deplate('xhtml10t')
+    end
+
+    def to_latex
+        deplate('latex')
+    end
+
+    def to_tex
+        deplate('latex')
+    end
+
+    def to_text
+        deplate('plain')
+    end
+
+    def to_dbk
+        deplate('dbk-article')
+    end
+end
+
+
+if __FILE__ == $0
+    puts DeplateString.new('bar __foo__ bar').to_html
+    puts DeplateString.new('bar __foo__ bar').to_xhtml
+    puts DeplateString.new('bar __foo__ bar').to_tex
+    puts DeplateString.new('bar __foo__ bar').to_text
+    puts DeplateString.new('bar __foo__ bar').to_dbk
+
+    t = <<EOF
+* Introduction
+
+''deplate'' is a tool for converting wiki-like markup to latex, html, or 
+"html-slides".
+EOF
+
+    puts DeplateString.new(t).to_html
+end
+

data/lib/deplate/docbook.rb

@@ -3,10 +3,10 @@
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     17-M�r-2004.
-# @Last Change: 01-Nov-2005.
-# @Revision:    0.2651
+# @Last Change: 05-Jun-2006.
+# @Revision:    0.2735
 
-require "deplate/xml"
+require 'deplate/xml'
 
 # An abstract docbook formatter
 
@@ -24,27 +24,27 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
         args ||= {}
         unless no_id
             id  = use_id(args, opts)
-            oid = opts["id"]
+            oid = opts['id']
             if oid and oid != id
-                log(["ID mismatch", id, oid, opts, args], :error)
+                log(['ID mismatch', id, oid, opts, args], :error)
             end
-            opts["id"] = encode_id(id) if id
+            opts['id'] = encode_id(id) if id
             # args = args.dup
-            args.delete("id")
+            args.delete('id')
         end
-        id = opts["id"]
+        id = opts['id']
         if id
             if @consumed_ids.include?(id)
                 opts = opts.dup
-                opts.delete("id")
+                opts.delete('id')
             else
                @consumed_ids << id
             end
-            opts["xreflabel"] ||= args[:level_as_string]
+            opts['xreflabel'] ||= args[:level_as_string]
         end
         opts = opts.collect do |k, v|
             case k
-            when "linkend"
+            when 'linkend'
                 v = encode_id(v)
             end
             if v
@@ -53,12 +53,12 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
         end
         if single
             if @sgml
-                opts << "></%s" % tag
+                opts << '></%s' % tag
             else
-                opts << "/"
+                opts << '/'
             end
         end
-        %{<%s>} % [tag, *opts].compact.join(" ")
+        %{<%s>} % [tag, *opts].compact.join(' ')
     end
    
     def get_close(tag, args=nil)
@@ -88,19 +88,19 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
             author = []
             if au[:firstname] and au[:surname]
                 firstname = @deplate.parse_and_format(nil, au[:firstname], false)
-                author << formatted_inline("firstname", firstname)
+                author << formatted_inline('firstname', firstname)
                 surname = @deplate.parse_and_format(nil, au[:surname], false)
-                author << formatted_inline("surname", surname)
+                author << formatted_inline('surname', surname)
             else
                 surname = @deplate.parse_and_format(nil, au[:name], false)
-                author << formatted_inline("surname", surname)
+                author << formatted_inline('surname', surname)
             end
             acc << author.join
             if au[:note]
                 authorblurb = @deplate.parse_and_format(nil, au[:note], false)
-                acc << formatted_block("authorblurb", formatted_inline("para", authorblurb))
+                acc << formatted_block('authorblurb', formatted_inline('para', authorblurb))
             end
-            accAuthors << formatted_block("author", join_blocks(acc))
+            accAuthors << formatted_block('author', join_blocks(acc))
         end
         return accAuthors
     end
@@ -111,28 +111,28 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
         authors    = @deplate.options.author || []
         accAuthors = docbook_authors(authors)
         if authors.size > 1
-            accum << formatted_block("authorgroup", join_blocks(accAuthors))
+            accum << formatted_block('authorgroup', join_blocks(accAuthors))
         else
             accum += accAuthors
         end
         
-        date = @deplate.get_clip("date")
-        date = date ? date.elt : Deplate::Element.get_date("today", nil)
-        accum << formatted_inline("pubdate", date)
+        date = @deplate.get_clip('date')
+        date = date ? date.elt : Deplate::Element.get_date('today', nil)
+        accum << formatted_inline('pubdate', date)
         
-        title = @deplate.get_clip("title")
-        accum << formatted_inline("title", title.elt) if title
+        title = @deplate.get_clip('title')
+        accum << formatted_inline('title', title.elt) if title
         
         kw = keywords
         if kw
-            kws = join_blocks(kw.collect {|kw| formatted_inline("keyword", kw)})
-            accum << formatted_block("keywordset", kws)
+            kws = join_blocks(kw.collect {|kw| formatted_inline('keyword', kw)})
+            accum << formatted_block('keywordset', kws)
         end
         
-        desc = @deplate.variables["description"]
+        desc = @deplate.variables['description']
         if desc
-            para = formatted_inline("para", plain_text(desc))
-            accum << formatted_block("abstract", para)
+            para = formatted_inline('para', plain_text(desc))
+            accum << formatted_block('abstract', para)
         end
             
         return join_blocks(accum)
@@ -141,12 +141,13 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
     def get_doc_def(args)
         version = @deplate.variables['dbkVersion'] || '4.2'
         type    = @deplate.variables['dbkClass']   || 'article'
+        oldnew  = @sgml ? 'sgml' : 'xml'
         dbkid   = @deplate.variables['dbkId']      || "-//OASIS//DTD DocBook XML V#{version}//EN"
-        dtd     = @deplate.variables['dbkDtd']     || "http://www.oasis-open.org/docbook/xml/#{version}/docbookx.dtd"
+        dtd     = @deplate.variables['dbkDtd']     || "http://www.oasis-open.org/docbook/#{oldnew}/#{version}/docbookx.dtd"
         docbook_doc_def(args, type, dbkid, dtd)
     end
 
-    def docbook_doc_def(args, type, pub, dtd, xmlVersion="1.0")
+    def docbook_doc_def(args, type, pub, dtd, xmlVersion='1.0')
         encoding = @encoding ? %{ encoding="%s"} % @encoding : ""
 
         doc = [%{<?xml version='#{xmlVersion}'#{encoding}?>},
@@ -155,15 +156,15 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
         ]
         ent = get_entities(args)
         if ent
-            doc.last << " ["
-            doc << ent << "]"
+            doc.last << ' ['
+            doc << ent << ']'
         end
-        doc.last << ">"
+        doc.last << '>'
         return join_blocks(doc.flatten.compact)
     end
    
     def get_entities(args)
-        entities = args[:deplate].variables["dbkEntities"]
+        entities = args[:deplate].variables['dbkEntities']
         return join_blocks(entities) if entities
     end
 
@@ -172,40 +173,40 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
     end
 
     # get_doc_body_open(args)
-    noop self, "get_doc_body_open"
+    noop self, 'get_doc_body_open'
 
     # get_doc_body_close(args)
-    noop self, "get_doc_body_close"
+    noop self, 'get_doc_body_close'
 
     # Bibliography
     def get_bib(args, title, bib)
         acc = [close_headings(1)]
-        title = formatted_inline("title", title) if title and !args["plain"]
-        acc << formatted_block("bibliography", join_blocks([title, bib].compact), nil, args)
+        title = formatted_inline('title', title) if title and !args['plain']
+        acc << formatted_block('bibliography', join_blocks([title, bib].compact), nil, args)
         join_blocks(acc)
     end
 
     def get_bib_entry(args, key, entry)
-        body = join_blocks([formatted_inline("abbrev", key), entry])
-        return formatted_block("biblioentry", body, {"id" => encode_id(key)}, args)
+        body = join_blocks([formatted_inline('abbrev', key), entry])
+        return formatted_block('biblioentry', body, {'id' => encode_id(key)}, args)
     end
 
     def docbook_format_authors(type, args, text)
         if text
             acc = []
-            for au in authors_split(text)
+            for au in Deplate::Core.authors_split(text)
                 author = Deplate::Names.name_match_sf(au) || Deplate::Names.name_match_fs(au)
                 if author
-                    surname   = formatted_inline("surname", author[:surname])
-                    firstname = formatted_inline("firstname", author[:firstname])
+                    surname   = formatted_inline('surname', author[:surname])
+                    firstname = formatted_inline('firstname', author[:firstname])
                     acc << formatted_inline(type, surname + firstname)
                 else
                     # is this ok???
-                    acc << formatted_inline(type, formatted_inline("surname", au))
+                    acc << formatted_inline(type, formatted_inline('surname', au))
                 end
             end
             if acc.size > 1
-                return formatted_block("authorgroup", join_blocks(acc), nil, args)
+                return formatted_block('authorgroup', join_blocks(acc), nil, args)
             else
                 return join_blocks(acc)
             end
@@ -213,70 +214,70 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
     end
     
     def get_bib_author(args, text)
-        docbook_format_authors("author", args, text)
+        docbook_format_authors('author', args, text)
     end
     
     def get_bib_year(args, text)
-        formatted_inline("pubdate", text)
+        formatted_inline('pubdate', text)
     end
 
     def get_bib_booktitle(args, text)
-        formatted_inline("title", text)
+        formatted_inline('title', text)
     end
 
     def get_bib_editor(args, text)
-        docbook_format_authors("editor", args, text)
+        docbook_format_authors('editor', args, text)
     end
 
     def get_bib_journal(args, text)
-        formatted_inline("title", text)
+        formatted_inline('title', text)
     end
 
     def get_bib_pages(args, text)
-        formatted_inline("pagenums", text)
+        formatted_inline('pagenums', text)
     end
 
     def get_bib_publisher(args, text)
-        formatted_block("publisher", formatted_inline("publishername", text), nil, args)
+        formatted_block('publisher', formatted_inline('publishername', text), nil, args)
     end
 
     def get_bib_title(args, text)
-        formatted_inline("title", text)
+        formatted_inline('title', text)
     end
 
     def get_bib_volume(args, text)
-        formatted_inline("volumenum", text)
+        formatted_inline('volumenum', text)
     end
 
     def get_bib_number(args, text)
-        formatted_inline("issuenum", text)
+        formatted_inline('issuenum', text)
     end
 
     def docbook_bib_sorted_values(entry)
-        keys = ["author", "title", "editor", "booktitle", "publisher", "journal", "volume", "number", "pages", "year"]
+        keys = ['author', 'title', 'editor', 'booktitle', 'publisher', 'journal', 'volume', 'number', 'pages', 'year']
         entry = entry.sort {|a, b| keys.index(a[0]) <=> keys.index(b[0])}
         entry.collect {|a| a[1..-1]}.flatten
     end
 
     def docbook_bib_relation(args, typeEntry, entry, typeContainer, container)
         e = join_blocks(docbook_bib_sorted_values(entry))
-        e = formatted_block("biblioset", e, {"relation" => typeEntry}, args)
+        e = formatted_block('biblioset', e, {'relation' => typeEntry}, args)
         c = join_blocks(docbook_bib_sorted_values(container))
-        c = formatted_block("biblioset", c, {"relation" => typeContainer}, args)
+        c = formatted_block('biblioset', c, {'relation' => typeContainer}, args)
         return join_blocks([e, c])
     end
     
     def get_bib_relation(args, type, entry, container)
         if type
             case type.downcase
-            when "article"
-                return docbook_bib_relation(args, "article", entry, "journal", container)
-            when "incollection"
+            when 'article'
+                return docbook_bib_relation(args, 'article', entry, 'journal', container)
+            when 'incollection'
                 # is this ok???
-                return docbook_bib_relation(args, "article", entry, "book", container)
+                return docbook_bib_relation(args, 'article', entry, 'book', container)
             end
         else
-            args[:self].log(["No bib entry type given", entry], :error)
+            args[:self].log(['No bib entry type given', entry], :error)
         end
         join_blocks(docbook_bib_sorted_values(entry.update(container)))
     end
@@ -284,15 +285,15 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
 
     # Text
     def get_block_abstract(args, text)
-        return formatted_block("abstract", text, nil, args)
+        return formatted_block('abstract', text, nil, args)
     end
 
     def get_block_longquote(args, text)
-        return formatted_block("blockquote", text, nil, args)
+        return formatted_block('blockquote', text, nil, args)
     end
 
     def get_block_quote(args, text)
-        return formatted_block("blockquote", text, nil, args)
+        return formatted_block('blockquote', text, nil, args)
     end
 
     def get_note(args, marker, text)
@@ -329,6 +330,69 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
     # get_list_of_figures(args, data)
     noop self, 'get_list_of_figures'
 
+    def listing_prematter(invoker, args, id)
+        case args[:listing]
+        when 'toc'
+            get_open('lot', {:id => id}, args)
+        else
+            args[:id] ||= id
+            get_list_itemize_open(args)
+        end
+    end
+    
+    def listing_postmatter(invoker, args)
+        case args[:listing]
+        when 'toc'
+            get_close('lot')
+        else
+            get_list_itemize_close(args)
+        end
+    end
+    
+    def listing_title(invoker, args, name)
+        if name
+            # case args[:listing]
+            # when 'toc'
+                formatted_inline('title', @deplate.msg(name))
+            # else
+            # end
+        end
+    end
+    
+    def listing_item(invoker, args, prefix, title, heading, level, other_args)
+        v = clean_tags(title)
+        # v = clean_tags(title, 'indexterm')
+        case other_args[:listing]
+        when 'toc'
+            v = [heading.level_as_string, v].join(' ') unless heading.plain_caption?
+            d = @deplate.elt_label(prefix, heading.level_as_string)
+            f = formatted_inline('lotentry', v, {'linkend' => d})
+            s = Deplate::ListItem.new(nil, nil, nil, nil, level, 0, true)
+            s.preformatted = [f, nil]
+        else
+            v = [heading.level_as_string, v].join(' ') unless heading.plain_caption?
+            d = @deplate.elt_label(prefix, heading.level_as_string)
+            s = Deplate::ListItem.new(nil, nil, nil, nil, level, 0, true)
+            f = join_blocks([
+                get_item_itemize_open(args, heading.level_as_string, v),
+                get_item_itemize_close(args)
+            ])
+            s.preformatted = [f, nil]
+        end
+        s
+    end
+
+    def clean_tags(text, *tags)
+        if text
+            tags = tags.empty? ? '\w+' : tags.join('|')
+            t = text.gsub(/<(#{tags}).*?>.*?<\/\1>|<(#{tags}).*?\/>/, '')
+            t.gsub!(/^\s*$/, '')
+            t.gsub!(/^\n\s*/, '')
+            t.gsub!(/\n\s*$/, '')
+            t
+        end
+    end
+
     def get_item_paragraph(args, item, text)
         formatted_inline('para', text)
     end
@@ -355,6 +419,31 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
         join_blocks([idt + get_close('listitem'), get_close('varlistentry')])
     end
 
+    # tasks
+    def get_list_task_open(args)
+        get_list_description_open(args)
+    end
+
+    def get_list_task_close(args)
+        get_list_description_close(args)
+    end
+
+    def get_item_task_open(args, item, text, opts)
+        pri  = opts[:priority]
+        cat  = opts[:category]
+        done = opts[:done] ? 'done' : nil
+        due  = opts[:due]
+        task = [cat, pri]
+        task << " #{due}" if due
+        # task = ['{', task, '}'].join
+        task = task.join
+        get_item_description_open(args, task, text)
+    end
+    
+    def get_item_task_close(args)
+        get_item_description_close(args)
+    end
+
     # itemize
     def get_list_itemize_open(args)
         get_open('itemizedlist', nil, args)
@@ -432,11 +521,16 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
     end
 
     def get_image(args, file, fnroot, inline=false)
+        if file =~ Deplate::HyperLink::Url.rx
+            Deplate::Core.log([%{Can't include remote images in current document}, file], :error)
+            file = File.basename(file)
+        end
         o = {}
         w = args['w'] || args['width']
         # h = args['h'] || args['heigth']
         unless w
-            desc = Deplate::External.image_dimension(File.join(@deplate.options.dir, file))
+            ifile = Deplate::Core.file_join(@deplate.options.dir, file)
+            desc  = Deplate::External.image_dimension(ifile)
             w, h, bx, by = desc[:bw]
         end
         o['width'] = w if w
@@ -469,7 +563,8 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
 
     # Footnote
     def get_footnote(args, label, text)
-        formatted_block('footnote', formatted_inline('para', text), {'id'=>label}, args)
+        # formatted_block('footnote', formatted_inline('para', text), {'id'=>label}, args)
+        formatted_block('footnote', text, {'id'=>label}, args)
     end
 
     def get_footnote_ref(args, label, text)
@@ -482,26 +577,39 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
         hd = @headings[level - 1]
         id = encode_id(args[:id])
         if hd
-            plain    = @deplate.variables['headings'] == 'plain' || args['plain']
-            id       = encode_id(args['shortcaption'] || text) if id.empty? or plain
+            plain = @deplate.variables['headings'] == 'plain' || args['plain']
+            no_id = id.empty?
+            if no_id or plain
+                id = encode_id(args['shortcaption'] || text)
+                if no_id
+                    args[:id] = id if no_id
+                    args[:self].log(['Internal error: No ID', @args[:self].class, text, label], :error)
+                end
+            end
             ho       = {}
-            ho['id'] = id unless id.empty?
+            # ho['id'] = id unless id.empty?
+            ho['id'] = id
             if plain
                 xreflabel       = id
                 ho['xreflabel'] = xreflabel
             else
-                ho['label']     = args[:level_as_string].split(/\./).last
-                # ho['label']     = args[:level_as_string]
-                xreflabel       = encode_id(args[:level_as_string])
-                ho['xreflabel'] = xreflabel
+                xlab           = args[:level_as_string]
+                if xlab
+                    ho['label']     = xlab.split(/\./).last
+                    # ho['label']     = args[:level_as_string]
+                    xreflabel       = encode_id(xlab)
+                    ho['xreflabel'] = xreflabel
+                else
+                    args[:self].log(['Internal error', 'No label'], :error)
+                end
             end
             hd = get_open(hd, ho, args)
-            unless id.empty?
+            # unless id.empty?
                 to = {'id' => "#{id}_title"}
                 to['xreflabel'] = xreflabel
-            end
+            # end
             ti = formatted_inline('title', text, to, args)
-            return join_blocks([hd, ti, label])
+            return join_blocks([hd, indent_text(ti), indent_text(label)])
         else
             label << id unless id.empty?
             get_paragraph(args, text, label)
@@ -552,33 +660,33 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
 
 
     # Labels, References
-    def get_label(args, label, mode, text="")
+    def get_label(args, label, mode, text='')
         case mode
         when :after, :closeOpen
             text
         else
-            join_inline([formatted_single("anchor", {"id" => encode_id(label)}), text])
+            join_inline([formatted_single('anchor', {'id' => encode_id(label)}), text])
         end
     end
 
     def get_ref(args, file, label, heading=nil)
         if label
-                if file.empty? and heading
+            if file.empty? and heading
                 if @sgml
                     o = @deplate.label_aliases[label]
                     text = o.args[:level_as_string]
-                    formatted_inline("link", text, {"linkend" => label}, args)
+                    formatted_inline('link', text, {'linkend' => label}, args)
                 else
-                    opts = {"linkend" => encode_id(label), 'endterm' => "#{heading}_title"}
-                    return formatted_single("xref", opts, args)
+                    opts = {'linkend' => encode_id(label), 'endterm' => "#{heading}_title"}
+                    return formatted_single('xref', opts, args)
                 end
             else
-                url = [file, label].join("#")
-                return formatted_inline("ulink", text, {"url" => "file://%s" % url}, args)
+                url = [file, label].join('#')
+                return formatted_inline('ulink', text, {'url' => 'file://%s' % url}, args)
             end
         else
-            args[:self].log("No label", :error)
-            return ""
+            args[:self].log('No label', :error)
+            return ''
         end
     end
 
@@ -591,12 +699,12 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
             %{</para><para>}
         else
             log(["Don't know how to insert linebreaks", container.class], :error)
-            ""
+            ''
         end
     end
 
     def get_pagebreak(args)
-        formatted_single("beginpage", nil, args)
+        formatted_single('beginpage', nil, args)
     end
 
     def get_paragraph(args, text, labels=[])
@@ -606,133 +714,133 @@ class Deplate::Formatter::Docbook < Deplate::Formatter::XML
         end
         acc << text
         text = join_blocks(acc)
-        return formatted_inline("para", text, nil, args)
+        return formatted_inline('para', text, nil, args)
     end
 
 
     # Table
     def get_table(args, title, table)
         opts  = {}
-        frame = args["frame"] || @deplate.variables["tableFrame"] || "topbot"
+        frame = args['frame'] || @deplate.variables['tableFrame'] || 'topbot'
         if frame
-            opts["frame"] = frame
+            opts['frame'] = frame
         end
         if title
-            formatted_block("table", join_blocks([title, table]), opts, args)
+            formatted_block('table', join_blocks([title, table]), opts, args)
         else
-            formatted_block("informaltable", table, opts, args)
+            formatted_block('informaltable', table, opts, args)
         end
     end
     
     def get_table_order
-        ["head", "foot", "body"]
+        ['head', 'foot', 'body']
     end
     
     def get_table_caption(args, title, text, capAbove)
-        formatted_inline("title", text)
+        formatted_inline('title', text)
     end
 
     def get_table_group_open(args, n)
-        acc = [get_open("tgroup", {"cols" => n}, args, :no_id => true)]
+        acc = [get_open('tgroup', {'cols' => n}, args, :no_id => true)]
         
-        colwidths = Deplate::Core.props(args["cols"], "w")
-        coljusts  = Deplate::Core.props(args["cols"], "j")
+        colwidths = Deplate::Core.props(args['cols'], 'w')
+        coljusts  = Deplate::Core.props(args['cols'], 'j')
         names     = []
         for i in 0 .. n - 1
             col = {}
 
             name = "c#{i}"
-            col["colname"] = name
+            col['colname'] = name
             names << name
 
             w = colwidths[i]
             if w and !w.empty?
-                col["colwidth"] = w
+                col['colwidth'] = w
             end
             
             j = coljusts[i]
             if j and !j.empty?
-                col["align"] = j
+                col['align'] = j
             end
-            acc << formatted_single("colspec", col, args, true)
+            acc << formatted_single('colspec', col, args, true)
         end
         args[:colnames] = names
         join_blocks(acc)
     end
 
     def get_table_group_close(args)
-        get_close("tgroup")
+        get_close('tgroup')
     end
 
     def get_table_head_open(args)
-        get_open("thead", nil, args, :no_id => true)
+        get_open('thead', nil, args, :no_id => true)
     end
 
     def get_table_head_close(args)
-        get_close("thead")
+        get_close('thead')
     end
 
     def get_table_foot_open(args)
-        get_open("tfoot", nil, args, :no_id => true)
+        get_open('tfoot', nil, args, :no_id => true)
     end
 
     def get_table_foot_close(args)
-        get_close("tfoot")
+        get_close('tfoot')
     end
 
     def get_table_body_open(args)
-        get_open("tbody", nil, args, :no_id => true)
+        get_open('tbody', nil, args, :no_id => true)
     end
 
     def get_table_body_close(args)
-        get_close("tbody")
+        get_close('tbody')
     end
 
     def get_table_head_cell(args, text, rown, coln, span_x=1, span_y=1)
         entry_args = {}
         if span_y > 1
-            entry_args["morerows"] = span_y - 1
+            entry_args['morerows'] = span_y - 1
         end
-        formatted_block("entry", formatted_inline("para", text), entry_args)
+        formatted_block('entry', formatted_inline('para', text), entry_args)
     end
 
     def get_table_cell(args, text, rown, coln, span_x=1, span_y=1)
         entry_args = {}
         if span_y > 1
-            entry_args["morerows"] = span_y - 1
+            entry_args['morerows'] = span_y - 1
         end
         if span_x > 1
             start = args[:colnames][coln]
-            entry_args["namest"]  = start
-            entry_args["nameend"] = args[:colnames][coln + span_x - 1]
+            entry_args['namest']  = start
+            entry_args['nameend'] = args[:colnames][coln + span_x - 1]
         end
-        formatted_block("entry", formatted_inline("para", text), entry_args)
+        formatted_block('entry', formatted_inline('para', text), entry_args)
     end
 
     def get_table_note(args, note)
-        formatted_inline("para", note)
+        formatted_inline('para', note)
     end
     
     def get_table_row_open(args)
-        get_open("row", nil, args, :no_id => true)
+        get_open('row', nil, args, :no_id => true)
     end
 
     def get_table_row_close(args)
-        get_close("row")
+        get_close('row')
     end
 
 
     # Title
-    noop self, "format_title"
+    noop self, 'format_title'
     # get_title(args, data, pagebreak)
-    noop self, "get_title"
+    noop self, 'get_title'
     # get_title_author(args, text)
-    noop self, "get_title_author"
+    noop self, 'get_title_author'
     # get_title_authornote(args, text)
-    noop self, "get_title_authornote"
+    noop self, 'get_title_authornote'
     # get_title_date(args, text)
-    noop self, "get_title_date"
+    noop self, 'get_title_date'
     # get_title_title(args, text)
-    noop self, "get_title_title"
+    noop self, 'get_title_title'
 end