docgenerator-creole 3.0.0

data/lib/docgenerator/creole/plugins.rb

@@ -0,0 +1,230 @@
+=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/docgenerator/creole/plugins/index.rb

@@ -0,0 +1,61 @@
+require 'docgenerator/index.rb'
+
+module Docgenerator
+  module Creole
+
+=begin rdoc
+Classes to provide support index.
+=end
+    module Index
+      #Required header to support index with makeindex.
+      HEAD_MAKEINDEX = "\\usepackage{makeidx}\\makeindex\n"
+=begin rdoc
+Classes to provide printindex.
+=end
+      class Creole_printindex < Creole_inclusion_and_plugin
+        set_plugin_key('printindex')  #use <<printindex>>
+        def to_doc(target, options = {})
+          element(:printindex, options).to_doc(target, options)
+        end    
+      end
+=begin rdoc
+Define a plugin for the indexnotes-package.
+=end
+      class Creole_index < Creole_inclusion_and_plugin
+        
+        set_plugin_key('index')  #use <<index|..>>
+        
+        #define default options for indexnotes. may be redefined for children of this class.
+        def default_options; {}; end
+
+=begin rdoc
+Usage:
+  <<index|what to do|color=red>>
+=end
+        def initialize( inclusionname, value, options, wiki )
+          #~ @inclusionname = inclusionname #fix 'index'
+          @value = value
+          @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("index #{@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(:index, @options, @value).to_doc(target, options)
+        end  
+      end #Creole_index
+
+    end #module index
+  end #module Creole
+end #module Docgenerator

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

@@ -0,0 +1,179 @@
+#encoding: utf-8
+=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
+
+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