docgenerator-creole 3.0.0

data/lib/docgenerator/creole/plugins/rubycode4creole.rb

@@ -0,0 +1,136 @@
+=begin rdoc
+Little helper to make documention on ruby scripts,
+Ruby fragments are defined in the creole-source,
+You can get the code and the results.
+
+The source code is enriched with the results and can be shown.
+=end
+
+#Only for quick tests
+$:.unshift("../../") if $0 == __FILE__ 
+
+#~ fixme: use listings instead verbatim
+#~ check usage??
+
+require 'docgenerator/creole'
+require 'docgenerator/packages/rubycode4doc'
+
+module Docgenerator
+  module Creole
+
+=begin rdoc
+Write rubycode inside creole-text
+=end
+    module Rubycode
+
+=begin rdoc
+Print ruby source code as is
+=end
+      class Code < Placeholder
+        set_placeholder_key 'rubycode'
+        #Return content in a verbatim environment
+        def to_doc( target, options = {})
+          codetest = Docgenerator::Rubycode::CodeTest.new(nil, @source.join )
+          #~ element(:verbatim,{},@source ).cr.to_doc( target, options )
+          element(:verbatim, {
+              :style => 'rubycode',
+            }, codetest.sourcecode ).cr.to_doc( target, options )
+        end  
+      end #Code
+
+      #
+      #Print ruby source code and put the result of each line as a comment.
+      #
+      #Example:
+      # 1 + 1
+      #becomes 
+      # 1 + 1   #2
+      class Code_evaluated < Placeholder
+        set_placeholder_key 'rubycode_evaluated'
+        #Return content in a verbatim environment
+        def to_doc( target, options = {})
+          codetest = Docgenerator::Rubycode::CodeTest.new(nil, @source.join )
+          #~ element(:verbatim,{},@source ).cr.to_doc( target, options )
+          element(:verbatim, {
+              :style => 'rubycode_evaluated',
+            }, codetest.code_evaluation ).cr.to_doc( target, options )
+        end  
+      end #Code_evaluated
+
+      #
+      #Print ruby source code and put the result of each line as a comment.
+      #
+      #Same as Code_evaluated, but export is done for in TeX-Package listings.
+      class Code_evaluated_listings < Placeholder
+        set_placeholder_key 'rubycode_evaluated_listings'
+        #Return content in a verbatim environment
+        def to_doc( target, options = {})
+          codetest = Docgenerator::Rubycode::CodeTest.new(nil, @source.join )
+          #~ element(:verbatim, {
+              #~ :style => 'rubycode_evaluated',
+            #~ }, codetest.code_evaluation ).cr.to_doc( target, options )
+         codetest.code_evaluation_lstlisting.to_doc( target, options )
+            
+        end  
+      end #Code_evaluated_listing
+
+      #
+      #Take only the output of the rubycode
+      #
+      class Code_output < Placeholder
+        set_placeholder_key 'rubycode_output'
+        #Return content in a verbatim environment
+        def to_doc( target, options = {})
+          codetest = Docgenerator::Rubycode::CodeTest.new(nil, @source.join )
+          #~ element(:verbatim,{},@source ).cr.to_doc( target, options )
+          element(:verbatim, {
+              :style => 'rubycode_output',
+            }, codetest.output ).cr.to_doc( target, options )
+        end  
+      end #Code_output
+
+      #
+      #Build a table.
+      #Each row corresponds with a source code line.
+      #You get source code, result and output of the code line.
+      #
+      #
+      class Code_in_tab < Placeholder
+        set_placeholder_key 'rubycode_in_tab'
+        #Return content in a verbatim environment
+        def to_doc( target, options = {})
+          codetest = Docgenerator::Rubycode::CodeTest.new(nil, @source.join )
+          codetest.code_in_tab.to_doc( target, options )
+        end  
+      end #Code_in_tab
+    end #module Rubycode
+  end #module Creole
+end #module Docgenerator
+
+if $0 == __FILE__
+    wiki = Docgenerator::Creole::Creole.new()
+    wiki << <<wiki
+rubycode
+<<<rubycode
+1 + 1
+>>>
+----
+rubycode_output
+<<<rubycode_output
+puts 1 + 1
+>>>
+----
+rubycode_evaluated
+<<<rubycode_evaluated
+1 + 1
+>>>
+----
+rubycode_in_tab
+<<<rubycode_in_tab
+1 + 1
+>>>
+wiki
+puts wiki.to_html
+end
+
+__END__

data/lib/docgenerator/creole/plugins/struktex.rb

@@ -0,0 +1,60 @@
+#encoding: utf-8
+=begin rdoc
+Add support of Struktex::Structogramm for Creole.
+=end
+#~ require 'docgenerator/creole'
+require 'docgenerator/packages/struktex.rb'
+
+module Docgenerator
+  module Creole
+
+=begin rdoc
+Define Creole placeholder.
+
+The placeholder insertion must contain three parameters:
+
+  >>>structogramm{Declarations/Interfaces;120;25}
+        Statement
+        ->	field1	description
+        <-	field2	description
+        <->	field3	description
+  <<<
+Details see Docgenerator::Structogramm
+=end
+    class Creole_structogramm < Placeholder
+      set_placeholder_key('structogramm')
+      
+    #~ fixme
+    #~ parameters optional als placeholder,
+    #~ hier aber benötigt. 
+    #~ Defaults??
+
+      def initialize( wiki, parameters = nil)
+        super
+        #~ @wiki = wiki
+        #~ @log  = @wiki.log
+        par = parameters ? parameters.split(/;/) : []
+        case par.size
+          when 0
+            raise ParameterError, "Creole_structogramm: Missing parameters"
+          when 3
+            title = par[0]
+            x = par[1]
+            y = par[2]
+            @source = ''
+            @structogramm = Packages::Struktex::Structogramm.new( title, x, y, @source )
+        else
+          raise ParameterError, "Creole_structogramm: Wrong number of parameters: #{parameters.inspect}"
+        end
+      end
+      #Instance of class Structogramm.
+      attr_reader :structogramm
+      
+      #Return content only for latex
+      def to_doc( target, options = {})
+        target == :latex ? @structogramm.to_doc( target, options ) : ''
+      end  
+    end #Creole_latex 
+
+  end #module Creole
+end #module Docgenerator

data/lib/docgenerator/creole/plugins/tikz.rb

@@ -0,0 +1,93 @@
+#encoding: utf-8
+=begin rdoc
+Example of usage:
+
+  <<<tikz_img|template_module.png|remember picture|width=\textwidth
+  \node[red,ultra thick,rounded corners,draw] at (.95,.75) (source) {1};
+  >>>
+  * (1) Datenquelle muss definiert werden<<tikz|\draw[] (0,0) -- (source);>>
+
+See also creole_example_tikz.rb
+=end
+#~ require 'docgenerator/packages/todonotes.rb'
+
+#
+module Docgenerator
+  module Creole
+    module Plugins
+=begin rdoc
+Define a TikZ inclusion.
+
+Usage: 
+
+  <<tikz|\draw[] (0,0) -- (1,1);>>
+  
+=end
+      class Creole_tikz < Creole_inclusion_and_plugin
+        Collection['tikz'] = self        
+        def to_doc(target, options = {})
+          target == :latex ?
+            '\tikz[overlay,remember picture]{%s}' % @description
+            : ''
+        end          
+      end
+      
+    end
+    
+    module Placeholders    
+=begin rdoc
+Include a graphic inside a tikz-environment
+
+Usage:
+  <<<tikz_img|template_module.png|width=\textwidth
+  \node[red,ultra thick,rounded corners,draw] at (.95,.75) {1};
+  >>>
+
+* parameters are
+  # the picture name
+  # alt=: Define alternative text (only HTML)
+  # remember picture: tikzpicture-option. Labels are added 'global'.
+  
+* The other options are forwarded to Inclusions::Creole_inclusion_img
+* Commands in the code are relative to image,
+  (0,0) is at the lower left of the picture and (1,1) is at the upper right.
+=end
+      class Tikz_img < Placeholder
+        set_placeholder_key 'tikz_img'
+        #Return content only for html
+        def to_doc( target, options = {})
+          parameters = @parameters.split('|')
+          picname = parameters.shift
+          alttext = nil
+          tikz_options = []
+          parameters.each{|par|
+            case par
+              when /alt\s*=\s*(.*)/
+                alttext = $1
+                parameters.delete(par)
+              when 'remember picture', '>=.*'
+                tikz_options << par
+                parameters.delete(par)
+            end
+          }
+          img = Inclusions::Creole_inclusion_img.new( picname, alttext, parameters, @wiki )
+          @source ||=[]
+          case target 
+            when :latex
+              <<'tex' % [tikz_options.join(','), img.to_doc( target, options ), @source.join.strip]
+\begin{tikzpicture}[%s]
+\node[anchor=south west,inner sep=0pt] (image) at (0,0)
+    {%s};
+\begin{scope}[x={(image.south east)},y={(image.north west)}]
+%s
+\end{scope}
+\end{tikzpicture}
+tex
+            else  #return only the graphic
+              img.to_doc( target, options )
+            end
+        end  #Tikz_img#to_doc
+      end #Tikz_img
+    end
+  end
+end

data/lib/docgenerator/creole/plugins/todonotes.rb

@@ -0,0 +1,77 @@
+require 'docgenerator/packages/todonotes.rb'
+
+module Docgenerator
+  module Creole
+
+=begin rdoc
+Classes to provide support for the todonotes-package.
+
+* http://ctan.org/tex-archive/macros/latex/contrib/todonotes/
+=end
+    module Todo
+
+      class Creole_todolist < Creole_inclusion_and_plugin
+        set_plugin_key('listoftodos')  #use <<todo|..>>
+        def to_doc(target, options = {})
+          element(:listoftodos, options).to_doc(target, options)
+        end    
+      end
+=begin rdoc
+Define a plugin for the todonotes-package.
+=end
+      class Creole_todo < Creole_inclusion_and_plugin
+        
+        set_plugin_key('todo')  #use <<todo|..>>
+        
+        #define default options for todonotes. may be redefined for children of this class.
+        def default_options; {}; end
+
+=begin rdoc
+Usage:
+  <<todo|what to do|color=red>>
+=end
+        def initialize( inclusionname, description, options, wiki )
+          #~ @inclusionname = inclusionname #fix 'todo'
+          @description = description
+          @options = default_options.dup
+          options.each{|opt|
+            case opt
+              when /color\s*=\s*/
+                @options[:color] = $~.post_match
+              when /inline/
+                @options[:inline] = true
+              else
+                wiki.log.warn("Todo #{@description} with undefined option #{opt}")
+              end
+            }
+          @wiki = wiki
+          
+          raise "Inclusion received no wiki but #{wiki.inspect}" unless wiki.is_a?(Creole)
+        end
+        
+        def to_doc(target, options = {})
+          element(:todo, @options, @description).to_doc(target, options)
+        end  
+      end #Creole_todo
+
+=begin rdoc
+A variant of Creole_todo with green color.
+=end
+      class Creole_todo_green < Creole_todo
+          set_plugin_key('todo_green') #use <<todo_green|..>>
+        #define default options for todonotes. may be redefined for children of this class.
+        def default_options; {:color => 'green'}; end
+      end
+
+=begin rdoc
+A variant of Creole_todo with inline-layout.
+=end
+      class Creole_todo_inline < Creole_todo
+        set_plugin_key('todo_inline') #use <<todo_inline|..>>
+        #define default options for todonotes. may be redefined for children of this class.
+        def default_options; {:inline => true}; end
+      end
+
+    end #module Todo
+  end #module Creole
+end #module Docgenerator

data/lib/docgenerator/creole/tabular.rb

@@ -0,0 +1,405 @@
+#encoding: UTF-8
+
+#
+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|
+            options = {}
+            options[:align] = 'right' if cell.content.join('xxx') =~ /\A\s*-?[\d,\.]+\s*\Z/
+            row << element(cell.type,options, 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 } if @cells
+        end
+        #Return number of cells
+        def size
+          if @cells
+            @cells.size
+          else
+            #fixme error?
+            0
+          end
+        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
+
+