docgenerator 2.1.1 → 3.0.0

data/lib/creole/creole_plugins.rb

@@ -1,230 +0,0 @@
-=begin rdoc
-Creole plugins
-
-This classes define plugins for creole.
-
-Plugins are used later with <<xx>>
-more at http://www.wikicreole.org/wiki/Plugin
-
-You can extend Wikis with additional Plugin:
-
- wiki = Creole.new()
- wiki.plugin['xxx'] = Creole_plugin_xxx
-=end
-
-#
-
-module Docgenerator
-  module Creole
-
-=begin rdoc
-Creole plugins
-
-This classes define plugins for creole.
-
-Plugins are used later with <<xx>>
-more at http://www.wikicreole.org/wiki/Plugin
-
-You can extend Wikis with additional Plugin:
-
- wiki = Creole.new()
- wiki.plugin['xxx'] = Creole_plugin_xxx
-=end
-    module Plugins
-
-=begin rdoc
-Default Plugin for Creole.
-  <<xx>>
-=end
-      class Creole_default_plugin < Creole_inclusion_and_plugin
-        def initialize( pluginname, description, options, wiki )
-          super
-          @wiki.log.warn("Use Default plugin instead requested #{pluginname}- nothing special done.") if @wiki.log.warn?
-        end
-      end
-
-      #Collection of Plugins
-      Collection = Hash.new(Creole_default_plugin)
-
-
-=begin rdoc
-Collection of footnotes.
-
-Makes sense for HTML-output.
-
-For LaTeX the support of bigfoot/manyfoot... may be an idea.
-=end
-      class Creole_footnote_group < Creole_inclusion_and_plugin
-        #
-        
-        Collection['footnotes'] = self
-        
-        def initialize( inclusionname, description, options, wiki )
-          super
-          description = Footnotegroup::DEFAULTGROUPID unless description
-          @footnotesgroup = wiki.footnotegroups[description]
-          wiki.log.error("Footnotesgroup #{description.inspect} not found") if ! @footnotesgroup and wiki.log.error?
-        end
-=begin rdoc
-Call Docgenerator::Footnotegroup#to_doc
-=end
-        def to_doc(target, options = {})
-          #remove options for Docgenerator::Footnotegroup
-          l_options = options.dup
-          l_options.delete(:plugins)
-          l_options.delete(:inclusions)
-          @footnotesgroup.to_doc(target, l_options)
-        end  
-      end #Creole_inclusion_footnote_group
-
-=begin rdoc
-One footnote
-
-Usage: 
-  <<footnote|text>>
-  <<footnote|text|label=l1>>
-  <<footnote|text|groupid=g1>>
-
-Bug: If you create more documents, you get a common footnote counting.
-
-Solution:
-* LaTeX: no problem, LaTeX has it's own output mechanism.
-* HTML: Use grouping.
-=end
-      class Creole_footnote < Creole_inclusion_and_plugin
-        Collection['footnote'] = self
-        
-        def initialize( inclusionname, description, options, wiki )
-          super
-          
-          @groupid = Footnotegroup::DEFAULTGROUPID
-          label = nil
-          
-          options.each{|option|
-            case option
-              when /label\s*=\s*(.*)/
-                label = $1
-              when /groupid\s*=\s*(.*)/
-                @groupid = $1
-              else
-              @wiki.log.warn("Footnote with unknown option #{option.inspect} not found") if @wiki.log.warn?
-            end
-          }
-          
-          if ! wiki.footnotegroups[@groupid]
-            wiki.footnotegroups[@groupid] = Footnotegroup.new(@groupid)
-          end
-
-          group = wiki.footnotegroups[@groupid]
-          
-          @footnote = element(:footnote,{ 
-            :group => group,
-            :label => label,
-            }, description )
-          
-          
-        end
-        def to_doc(target, options ={})
-          @footnote.to_doc(target, options)
-        end  
-      end #Creole_inclusion_footnote
-
-=begin rdoc
-Some short latex
-
-Usage: 
-  <<latex|code>>
-
-Note:
-There is also a placeholder for larger latex:
-  <<<latex
-  content
-  >>>
-=end
-      class Creole_short_latex < Creole_inclusion_and_plugin
-        #We don't use it as inclusion. Closing } from latex may be confusing as in:
-        # {{latex|\texttt{kursuiv}}}
-        set_plugin_key 'latex'
-        
-        def initialize( inclusionname, description, options, wiki )
-          super
-          options.each{|option|
-            #~ case option
-              #~ else
-              @wiki.log.warn("latex with unknown option #{option.inspect} not found") if @wiki.log.warn?
-            #~ end
-          }
-          @source = description
-          
-        end
-        #Return content only for latex
-        def to_doc( target, options = {})
-          target == :latex ? @source.to_doc( target, options ) : ''
-        end  
-      end #Creole_short_latex
-
-
-=begin rdoc
-Eval the given ruby-code and put it as "raw text".
-
-
-This is defined as a plugin.
-=end
-      class Creole_plugin_ruby_raw < Creole_inclusion_and_plugin
-        set_plugin_key 'ruby_raw'
-        
-        def initialize( inclusionname, description, options, wiki )
-          #The ruby-code may contain | - so we have to ad it again
-          description << "|#{options.join('|')}" unless options.empty?
-          options = nil
-          super
-          @code = description
-          begin
-            @result = eval(@code)
-          rescue => bang
-            wiki.log.error("Plugin ruby_raw: <#{@code}> results in #{bang.class}/#{bang}") if wiki.log.error?
-          end
-        end #initialize
-        def to_doc(target, options ={})
-          @result.to_s
-        end  
-        def inspect()
-          "#<Creole_plugin_ruby_raw:#{@code}>"
-        end
-      end #Creole_plugin_ruby
-
-=begin rdoc
-Eval the given ruby-code and add it as a interpreted code.
-
-This is defined as a plugin.
-
-Ideas for further development: eval later, at doc generation.
-=end
-      class Creole_plugin_ruby < Creole_inclusion_and_plugin
-        set_plugin_key 'ruby'
-        
-        def initialize( inclusionname, description, options, wiki )
-          #The ruby-code may contain | - so we have to ad it again
-          description << "|#{options.join('|')}" unless options.empty?
-          options = nil
-          super
-          
-          @code = description
-          begin
-            @result = eval(@code)
-          rescue => bang
-            wiki.log.error("Plugin ruby: <#{@code}> results in #{bang.class}/#{bang}") if wiki.log.error?
-          end
-        end #initialize  
-        def to_doc(target, options = {})
-          @wiki.normsource2elements( 
-                        @wiki.parse(@result.to_s ), options
-                  ).to_doc(target, options )
-        end  
-        def inspect()
-          "#<Creole_plugin_ruby:#{@code}>"
-        end
-      end #Creole_plugin_ruby
-    end #module Plugins
-  end #module Creole
-end #module Docgenerator

data/lib/creole/creole_tabular.rb

@@ -1,401 +0,0 @@
-#encoding: UTF-8
-
-if $0 == __FILE__ #for immediate tests  
-  $:.unshift('..')
-  require 'creole/creole2doc.rb' 
-end
-
-module Docgenerator
-  module Creole
-=begin
-"Original" creole tab. 
-
-Defined as a collector, so we can collect the content first and 
-build the tabular later.
-
-Details see http://www.wikicreole.org/wiki/Tables
-
-Usage:
-  Tables are done like this:
-  |=header col1|=header col2| 
-  |col1|col2| 
-  |you         |can         | 
-  |also        |align\\ it. | 
-
-=end
-    class Creole_tab < Placeholder
-      set_placeholder_key 'creole_tabular' #original creole-tab definition
-
-      #Extend the class by a little structure
-      Cell = Struct.new('Cell', :content, :type )  
-
-      #Finish the tabular.
-      #Each cell is added left justified.
-      def close(options)
-        #~ @log.error("Standard creole tabulars not supported yet" )
-        
-        step = 0  #start
-        head = []
-        content = []
-        @source.each{|line|
-          content << []
-          #delete trailing empty cells
-          line.chomp.gsub(/\|\s*$/,'').split(/\|/)[1..-1].each{|cell|
-            case cell
-              when /^=/
-              content.last << Cell.new(@wiki.inline($~.post_match.strip, options),:th)
-            else
-              content.last << Cell.new(@wiki.inline(cell.strip, options), :td)
-            end
-          }
-        }
-        
-        max_size = 0
-        content.each{|line|
-          max_size = [max_size, line.size].max
-        }
-        
-        @tab = element(:tabular, {#:style => tab_css,
-                                :columns => max_size,
-                                :columndescription => 'l' * max_size,
-                            }).cR
-        content.each{|line|
-          @tab << row = element(:row).cr
-          line.each{|cell|
-            row << element(cell.type,{}, cell.content).cr
-          }
-        }
-      end
-      def to_doc( target, options = {})
-        self.close(options) unless @tab
-        @tab.to_doc( target, options )
-      end  
-  end #Creole_tab
-
-=begin rdoc
-Create tabulars analog to Wikimedia.
-
-Usage:
-  before
-  <<<tabular
-  |!columns=3
-  |!columndescription=ccc
-  |!border=1px
-  |!css= color: red
-  |=1
-  |=2
-  |=3
-  |-
-  |eins
-  |zwei
-  |drei
-  |-
-  |one
-  |two
-  |three
-  >>>
-  after
-
-You can add additional settings to cells:
-  <<<tabular
-  |!columns=3
-  |eins||css=color: red
-  |css = zwei
-  |||class=empty
-  >>>
-=end
-    class Creole_tabular < Placeholder
-      set_placeholder_key 'tabular'
-      
-      #Define a container for cells
-      class Row 
-        #Flag for hline
-        attr_accessor :hline
-        #Flag for toprule
-        attr_accessor :toprule
-        #Flag for midrule
-        attr_accessor :midrule
-        #Add a cell to a row
-        def << (cell)
-          @cells = [] unless @cells
-          @cells << cell
-        end
-        def each
-          @cells.each{|cell| yield cell }
-        end
-        #Return number of cells
-        def size; @cells.size; end
-      end
-      #Extend the class by a little structure
-      class Cell 
-=begin rdoc
-The content of a cell is separated from settings by two ||
-
-If you have an empty cell with additional setting, you must write three |
-
-Supported additional settings:
-* css= define css-style options
-* class= define HTML-class
-* title= define a title (results in popup during mouse-over)
-=end
-        def initialize( content, type, wiki, local_options )
-          @content, options = content.split(/\|\|/,2)
-          @content = '' unless @content #just in case of empty content
-          @options = {}
-          options.split(/\|/).each{|option|
-            case option
-              when /class\s*=\s*/
-                @options[:class] = $~.post_match
-              when /css\s*=\s*/
-                @options[:style] = $~.post_match
-              when /title\s*=\s*/
-                @options[:title] = $~.post_match
-              when /pos\s*=\s*/ #only for multicol
-                @options[:pos] = $~.post_match
-              when /columns\s*=\s*/
-                wiki.log.debug("Creole_tabular::Cell #{type} converted to multicol")
-                type = :multicolumn #loose th/td-information -- fixme 
-                @options[:colspan] = $~.post_match.to_i
-              when '' #ignore them
-              else
-                wiki.log.warn("Creole_tabular::Cell: Undefined option #{option.inspect}")
-              end
-          } if options
-          @type  = type #:td or :th
-          @wiki   = wiki
-          @local_options = local_options
-        end
-        #Return the content as a element.
-        def cell_element()
-          element(@type,@options, @wiki.inline(@content, @local_options)).cr
-        end
-      end #class Cell
-      
-      #Build the tabular.
-      def close()
-        #~ fixme:
-        #~ *CSS-format
-        #~ *generelle def
-        
-        step = 0  #start
-        head = []
-        content = [Row.new]
-        
-        options = { :log => @log }
-        local_options = {
-                        :log => @log,
-                        :inclusions => @wiki.inclusions,
-                        :plugins => @wiki.plugins.dup
-        }
-        #No footnotes inside tabulars
-        local_options[:plugins].delete('footnote')
-        local_options[:plugins].delete('footnotes')
-        
-        tab_css = CSS.new( :log => @log )
-        @source.each{|cell|
-          case cell
-            when /^\|!/   #generell cell definition
-              case $~.post_match().strip
-                when /columns\s*=\s*(.*)/
-                  options[:columns] = $1.to_i
-                when /border\s*=\s*(.*)/
-                  options[:border] = $1
-                when /columndescription\s*=\s*(.*)/
-                  options[:columndescription] = $1
-                when /css\s*=\s*(.*)\s*:\s*(.*)/
-                  tab_css[$1] = $2
-                when '' #
-                else
-                  @log.warn("#{self}: Unknown tabular option #{$1}") if @log.warn?
-              end
-            when /^\|-(.*)/   #new line
-              if $1 #there are options for the row
-                $1.split(/\|/).each{|option|
-                  case option
-                    when /hline/;     content.last.hline    = true
-                    when /toprule/; content.last.toprule = true
-                    when /midrule/; content.last.midrule = true
-                    when /\A\s*\Z/, nil
-                    else
-                      @log.warn("#{self}: Unknown row option #{option.inspect}") if @log.warn?
-                  end
-                }
-              end
-              content << Row.new  #Start new row
-            when /^\|=/  #header cell
-              #~ content.last << Cell.new(@wiki.inline($~.post_match.strip, local_options), :th)
-              content.last << Cell.new($~.post_match.strip, :th, @wiki, local_options)
-            when /^\|/    #content of a cell
-              #~ content.last << Cell.new(@wiki.inline($~.post_match.strip, local_options), :td)          
-              content.last << Cell.new($~.post_match.strip, :td, @wiki, local_options)
-            else  #error!
-              raise "cell/log-warning in #{cell.inspect}"
-            end
-        }
-        
-        max_size = 0
-        content.each{|line|
-          max_size = [max_size, line.size].max
-        }
-        
-        if options[:columns] and options[:columns] < max_size
-          @log.warn("Creole-tabular: Defined size #{options[:columns]} < no of columns (#{max_size})") if @log.warn?
-        end
-        
-        if self.is_a?(Docgenerator::Creole::Creole_longtable)
-            @tab = element(:longtable, { :style => tab_css,
-                          }.merge(options) ).cR
-        #~ elsif self.is_a?(Docgenerator::Creole::Creole_supertabular)  #Not supported
-            #~ @tab = element(:supertabular, { :style => tab_css,
-                          #~ }.merge(options) ).cR
-        elsif self.is_a?(Docgenerator::Creole::Creole_tabular)
-            @tab = element(:tabular, { :style => tab_css,
-                                }.merge(options) ).cR
-        else
-          raise ArgumentError, "Unsupported tabular-class #{self.class}"
-        end
-        
-        content.each{|line|
-          @tab << row = element(:row).cr
-          row.hline if line.hline
-          row.toprule if line.toprule
-          row.midrule if line.midrule
-          line.each{|cell|
-            row << cell.cell_element.cr
-          }
-        }
-      end  
-      def to_doc( target, options = {})
-        @tab.to_doc( target, options )
-      end
-    end #Creole_tabular
-
-    class Creole_longtable < Creole_tabular
-      set_placeholder_key 'longtable'
-    end
-    
-    #~ class Creole_supertabular < Creole_tabular  ##Not supported
-      #~ set_placeholder_key 'supertabular'
-    #~ end
-=begin rdoc
-This class needs the CSV-package (the user is responsible to load it).
-
-The LaTeX document needs the booktabs-package
-
-Options:
-* headers=false: Firest line contains headers (default: true)
-* format or columndescription: LaTeX header description
-
-Fixmes:
-* More parameters:
-** toprule, hline, 
-** Other table (supertabular...)
-* Bug: CSV without header returns Array of array
-
-=end
-    class Creole_tabular_csv < Placeholder
-      set_placeholder_key 'tabular_csv'
-      def to_doc( target, options = {})
-         if ! defined? CSV
-          @log.fatal("tabular_csv needs CSV-package")
-          raise "tabular_csv needs CSV-package"
-        end
-        @log.fatal("tabular_csv needs parameters (format, col_sep)") unless @parameters.respond_to? :split
-        columndescription = nil
-        headers = true  #first CSV-line contains 
-        colsep = ';'
-        @parameters.split(/[|;]/).each{|parameter|
-          case parameter
-            when /headers=false/;     headers = false
-            when /(format|columndescription)=(.*)/; columndescription = $2
-            #Some separator get a name. This is made especially, of the separator is also used as parameter separator.
-            when /(col_sep)=(.*)/; colsep = {'semicolon' => ';', 'tab' => "\t", 'bar' => '|'}[$2] || $2  
-              @log.warn("tabular_csv with undefined separator (use semicolon, tab or bar)" % parameter) unless colsep
-            else
-              @log.warn("tabular_csv with unknown option %s" % parameter)
-          end
-        }
-
-        csv = CSV.parse(@source.join, :col_sep => colsep, :headers => true)
-        if ! columndescription
-          columndescription = 'c' * csv.headers.size
-          @log.warn("tabular_csv without LaTeX columndescription. Use %s" % columndescription)
-        end
-        tab = element(:tabular, { :columns => csv.headers.size, :columndescription  => columndescription }).cR
-        tab << row = element(:row).cr.toprule
-        csv.headers.each{|title|row << element(:th,{}, title) }
-        csv.each{|line|
-          tab << row = element(:row).cr
-          line.each{|cell|
-            row << element(:td,{}, cell.last)
-          }
-        }
-        tab.to_doc( target, options )
-      end      
-    end
-
-  end #module Creole
-
-end #module Docgenerator
-
-
-if $0 == __FILE__
-  
-  creole = Docgenerator::Creole::Creole.new(
-                    :name => 'tabular_creole',
-                    :content => <<'creole'
-<<<tabular
-|!columns=3
-|!columndescription=ccc
-|=a
-|=b
-|=c
-|-
-|a
-|b
-|c
->>>
-creole
-    )
-  require 'csv'
-  creole = Docgenerator::Creole::Creole.new(
-                    :name => 'tabular_creole',
-                    :content => <<'creole'
-<<<tabular_csv|columndescription=rrr|col_sep=semicolon
-1;2;3
-yy;yy;yy;
-xx;xx;xx;
->>>
-creole
-    ) #if false
-    
-  puts creole.to_html #testcode
-  puts creole.to_latex #testcode
-end    
-__END__
-
-class Creole_tabular_cvs
-  include Placeholder
-  
-<<<tabular_csv|CSV-Options
-yy;yy;yy;
-yy;yy;yy;
-yy;yy;yy;
-<<<
-
-
-Die Syntax:
-  *{|	beginnt eine Tabelle. Hier können zusätzliche Formatierungseigenschaften kommen.
-  **Zumindest columns==__ sollte gesetzt sein
-  *!		beginnt eine neue Zelle einer Titelzeile
-  *|		beginnt eine neue Zelle
-  *|format|	z.B. rowspan...
-  *|format||	Zwei || beenden die Parameter der Zelle.
-    Dann sinnvoll, wenn im Text selbst ein | vorkommt
-    (z.B. ein Macro verwendet wird)
-  *|-	trennt zwei Zeilen der Tabelle
-  **hline:	Zusätzlicher Trennstrich über der Zeile
-  **toprule, midrule, bottomrule:	Zusätzlicher Trennstrich über der Zeile (erfordert booktabs.sty)
-  *|}	beendet eine Tabelle
-
-