docgenerator 1.2.1 → 2.0.0

data/lib/creole/creole_placeholder.rb

@@ -1,3 +1,6 @@
+module Docgenerator
+module Creole
+
 =begin rdoc
 Placeholder are defined in Creole-Syntax via <<< >>>
 
@@ -7,18 +10,33 @@ Placeholders get a name and optional parameters:
 Placeholders collect the content between <<< and >>>. 
 
 Derived classes are:
-- Creole_dummy_placeholder
-- Creole_html
-- Creole_latex
-- Creole_tabular
-- Creole_creoletab
+- Creole::Placeholders::Dummy
+- Creole::Placeholders::Html
+- Creole::Placeholders::Latex
+- Creole::Creole_tabular
+- Creole::Creole_tab
 =end
-class Creole_placeholder
-  include Docgenerator  #get VERSION  
+class Placeholder
+=begin rdoc
+Define meta-methods for Creole_inclusion_and_plugin
+=end 
+  class << self
+=begin rdoc
+Define class as a placeholder.
+You may use the class as:
+  {{key}}
+=end 
+    def set_placeholder_key(key)
+      Placeholders::Collection[key] = self
+    end
+  end
+  
+  #Error is thrown, if the parameters don't fit the need of the placeholder
+  class ParameterError < ArgumentError; end;
 =begin rdoc
 Each placeholder get the wiki where it belongs to.
 
-Parameters are optional.
+Parameters is an optional string.
 
 Definition inside the wiki:
  <<<name|parameters
@@ -26,9 +44,8 @@ Definition inside the wiki:
  >>>
 Placeholders collect the content between <<< and >>>.
 =end
-  def initialize( wiki, parameters = nil )
+  def initialize( wiki, parameters = nil)
     @wiki = wiki
-    #
     @parameters = parameters
     @log  = @wiki.log
   end
@@ -47,16 +64,30 @@ Placeholders collect the content between <<< and >>>.
   def to_doc( target, options = {})
     @source.to_doc( target, options )
   end
-end #Creole_placeholder
+end #Placeholder
+
+
+=begin rdoc
+Collection of Placeholder-children
 
+Placeholders are used via <<<...>>>.
+=end
+module Placeholders  
 =begin rdoc
 Just a dummy for wrong definitions.
 
 This class is used by Creole a default placeholder.
 =end
-class Creole_dummy_placeholder < Creole_placeholder
-  Creole::Placeholders.default = self
-end #Creole_dummy_placeholder
+class Dummy < Placeholder
+end #Placeholder::Dummy
+
+#List of defined Placeholders.
+Collection = Hash.new( Dummy )
+#Get a Placeholder.
+def self.[](key)
+  Collection[key]
+end
+
 
 =begin rdoc
 Placeholder for pure HTML-output.
@@ -71,8 +102,8 @@ Note:
 There is also a plugin for short html:
   {{html|code}}
 =end
-class Creole_html < Creole_placeholder
-  Creole::Placeholders['html'] = self
+class Creole_html < Placeholder
+  set_placeholder_key 'html'
   #Return content only for html
   def to_doc( target, options = {})
     target == :html ? @source.to_doc( target, options ) : ''
@@ -90,8 +121,8 @@ Pro:
 Cons:
 -unexpected conversions?
 =end
-class Creole_latex < Creole_placeholder
-  Creole::Placeholders['latex'] = self
+class Creole_latex < Placeholder
+  set_placeholder_key 'latex'
   #Return content only for latex
   def to_doc( target, options = {})
     target == :latex ? @source.to_doc( target, options ) : ''
@@ -101,8 +132,8 @@ end #Creole_latex
 #
 #Collect 
 #
-class Creole_comment < Creole_placeholder
-  Creole::Placeholders['comment'] = self
+class Creole_comment < Placeholder
+  set_placeholder_key 'comment'
   #Return content as a comment
   def to_doc( target, options = {})
     case target
@@ -124,13 +155,16 @@ class Creole_comment < Creole_placeholder
   def to_creole(options = {})
     return "<<<comment\n#{@source.join}>>>"
   end
-end #Creole_html 
+end #Creole_comment
+
+end #module Placeholders
+
+end #module Creole
+end #module Docgenerator
 
 
 __END__
 To be done:
-class Creole_rail
-class Creole_struktogramm
 rubycode (see plugin  Creole_plugin_ruby )
 
 Steuerparameter mit | nach plugin-name?

data/lib/creole/creole_plugins.rb

@@ -0,0 +1,198 @@
+=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
+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 #initioliaze
+  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 #initioliaze  
+  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

@@ -16,6 +16,8 @@ lineoptions:
 fixme
 
 
+module Docgenerator
+module Creole
 
 =begin
 "Original" creole tab. 
@@ -33,8 +35,8 @@ Usage:
   |also        |align\\ it. | 
 
 =end
-class Creole_creoletab < Creole_placeholder
-  Creole::Placeholders['creole_tabular'] = self #original creole-tab definition
+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 )  
@@ -91,6 +93,8 @@ Usage:
   <<<tabular
   |!columns=3
   |!columndescription=ccc
+  |!border=1px
+  |!css= color: red
   |=1
   |=2
   |=3
@@ -113,8 +117,8 @@ You can add additional settings to cells:
   |||class=empty
   >>>
 =end
-class Creole_tabular < Creole_placeholder
-  Creole::Placeholders['tabular'] = self
+class Creole_tabular < Placeholder
+  set_placeholder_key 'tabular'
   
   #Extend the class by a little structure
   class Cell 
@@ -182,6 +186,8 @@ Supported additional settings:
           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*(.*)/
@@ -225,12 +231,13 @@ Supported additional settings:
   def to_doc( target, options = {})
     @tab.to_doc( target, options )
   end
-  
 end
+end #module Creole
+end #module Docgenerator
 
 
 if $0 == __FILE__
-    creole = Creole.new(
+    creole = Docgenerator::Creole::Creole.new(
                     :name => 'tabular_creole',
                     :content => <<'creole'
 <<<tabular
@@ -238,15 +245,16 @@ if $0 == __FILE__
 >>>
 creole
     )
-puts creole.to_html
+p creole.to_html #testcode
 end    
 __END__
 
 class Creole_tabular_cvs
-  include Creole_placeholder
+  include Placeholder
 >>>tab
 |!  Tabdefinition crl
 |! implizit columns
+|! border=1px
 |=  -> th
 yy;yy;yy;
 yy;yy;yy;

data/lib/creole/plugins/rail.rb

@@ -0,0 +1,182 @@
+=begin rdoc
+Support for the rail package.
+
+This is support for LaTeX-style rail.
+Don't be confused with ruby on rails - there is no intersection of the two packages.
+=end
+
+require 'creole/creole2doc'
+
+module Docgenerator
+module Creole
+=begin rdoc
+Support for the rail package.
+
+This is support for LaTeX-style rail.
+
+* http://www.ctan.org/tex-archive/support/rail/
+=end
+module Rail
+
+#
+#A Wrapper for the Creole-placeholder for Rail-diagramms.
+#
+class Diagramm4Creole < Placeholder
+  set_placeholder_key 'rail'
+
+  def initialize( wiki, name = 'Raildiagramm')
+    super
+    @name = name
+    raise ParameterError, "Missing id for rail-diagramm" unless @name
+    raise ParameterError, "Id for rail-diagramm contains no-letter" unless @name =~ /\A\w+\Z/
+  end
+  
+#fixme
+    #Check if the rail-diagramm is available as a picture.
+    #~ @filename = "#{@key}.png"
+    #~ if ! File.exist?( @filename )
+      #~ @filename = nil
+    #~ end
+
+
+=begin rdoc
+Return content only for LaTeX
+=end
+  def to_doc( target, options = {})
+  #fixme: Einmalig beim initialisieren
+  #fixme: Varianten erledigen
+  #fixme: Bild falls verf�gbar
+  #fixme: nur TeX (oder Bild)
+  #fixme logs
+    #~ case options[:elementtype]
+      #~ when nil    #ignore diagramm
+      #~ when :minipage
+        #~ return to_element_minipage()
+      #~ when :figure
+        #~ return to_element_figure()
+      #~ when :figure_img
+        #~ return to_element_figure_img()
+      #~ when :latexonly
+        #~ return element(:latexonly,{}, self.to_latex_rail ).cr
+      #~ else
+        #~ option[:log].error("Raildiagramm#to_element: Undefined type #{@@elementtype}") if option[:log].error?
+      #~ end
+    
+    #fixme Bild?
+    Rail_diagramm.new( @name, @source ).to_doc( target, options )
+  end    
+  #Check for picture and return a :img-macro (Only html)
+  def to_img()
+    return element( :img, { :src => @filename }) if @filename
+  end
+  #~ def to_element_figure()
+    #~ figure  = element(:figure).cr
+    #~ figure  << self.to_s
+    #~ figure  << element(:caption,{}, "Rail-Diagramm #{@key}" ).Cr
+    #~ return figure 
+  #~ end
+  #~ def to_element_figure_img()
+    #~ if @filename
+      #~ figure  = element(:figure, { :style => CSS.new(
+                      #~ :text_align => 'center',
+                      #~ :float  => 'right'
+                    #~ )}).cr
+      #~ figure  << self.to_img 
+      #~ figure  << element(:br).cr
+      #~ figure  << element(:caption,{}, "Rail-Diagramm #{@key}" ).Cr
+    #~ else
+      #~ figure = nil
+    #~ end
+    #~ return figure 
+  #~ end
+  #~ #Requires caption.sty
+  #~ #  doc.head  << element(:usepackage,{}, 'caption') 
+  #~ def to_element_minipage()
+    #~ figure  = element(:minipage, {:width => '\textwidth'} ).CR
+    #~ figure  << element(:centering)
+    #~ figure  << self.to_s
+    #~ figure  << element(:captionof,{ :float_type => 'figure' }, "Rail-Diagramm #{@key}" ).Cr
+    #~ return figure 
+  #~ end
+end #Rail_diagramm4Creole
+
+#
+#A Rail-diagramm
+#
+class Rail_diagramm
+
+  #Can be used in document header to load rail.sty
+  TEX_PACKAGE_RAIL  = element(:usepackage,{ }, 'rail').cr
+  #Some command to be added in document header.
+  #Allows the usage of some characters as terminals.
+  RAIL_ALIAS  = <<'RAIL_ALIAS'
+\railalias{lbrace}{\{}
+\railalias{rbrace}{\}}
+\railalias{dollar}{\$}
+\railalias{underscore}{\_}
+\railalias{percent}{\%}
+\railalias{at}{@}
+\railalias{atat}{@@}
+% \railalias{backslash}{\char"5C}
+\railalias{backslash}{\ensuremath{\backslash}}
+\railalias{lt}{\ensuremath{<}}
+\railalias{le}{\ensuremath{<=}}
+\railalias{gt}{\ensuremath{>}}
+\railalias{ge}{\ensuremath{>=}}
+\railalias{caret}{\ensuremath{\hat{}}}
+\railalias{tildeeq}{\ensuremath{\sim=}}
+\railalias{quote}{'}
+\railalias{dquote}{"}%german: \dq
+\railterm{quote,dquote}
+\railterm{lbrace,rbrace,dollar,percent,backslash,underscore,at,atat}
+\railterm{lt,le,gt,ge,caret,tildeeq}
+RAIL_ALIAS
+#~ \railalias{ampersand}{\&} -> umgesetht nachh << head>>
+
+  #Create new Rail diagramm.
+  #Parameter:
+  #-key 
+  #-rail-definition
+  def initialize( key, code = '' )
+    @key  = key
+    @code  = code
+  end
+  #Implement << for Wikicollector
+  def << (code)
+    @code << code
+  end
+=begin  
+Return LaTeX-environment rail
+Requires rail.sty and rail.exe to generate the figure.
+
+
+=end 
+  def to_latex(options = {})
+    @code = @code.join if @code.respond_to?(:join) #if Array is given
+    return <<-RAIL
+%
+% Define a rail-diagramm #{@key}
+%
+\\begin{rail}
+#{@key} :
+#{@code.chomp}
+;
+\\end{rail}
+RAIL
+  end #to_latex
+  def to_doc( target, options = {})
+    case target
+      when :latex 
+        self.to_latex( options )
+      else
+        o = set_option_defaults(options)
+        #~ o[:log].debug("enter to_doc(#{target}) for #{self.inspect}, options: #{options.keys.inspect}") if o[:log].debug?
+        o[:log].error("Rail-diagramm not supported for #{target}") if o[:log].error?
+        ''
+    end #case target
+  end #to_doc 
+end
+
+end #module Rail
+end #module Creole
+end #module Docgenerator