docgenerator 1.2.1 → 2.0.0

data/lib/docgenerator/packages/struktex.rb

@@ -0,0 +1,447 @@
+=begin rdoc
+Code-generator for structex, a TeX-package to create Nassi-Shneidermann diagramms.
+
+See examples a demonstration.
+
+This plugin is defined for Creole and Wikitext.
+Depending which classes are already defined, they are added as plugins.
+
+=end
+require 'docgenerator'
+
+=begin rdoc
+Extend Array class to build structogramms.
+=end
+class Array
+=begin rdoc  
+Recursive extension for all structogramm elements.
+So we can avoid a check, if the method is available.
+=end
+	def to_structex
+		return self.map{|e|
+			if e.respond_to?( :to_structex )
+				e.to_structex
+			else
+				e
+			end
+		}.flatten
+	end
+end
+
+
+module Docgenerator
+module Packages
+=begin rdoc
+Classes to provide support for the LaTeX-class struktex.
+
+* http://www.ctan.org/tex-archive/macros/latex/contrib/struktex/
+=end
+module Struktex
+USEPACKAGE_STRUKTEX	= element(:usepackage,{}, 'struktex').cr
+USEPACKAGE_STRUKTEX_PROOF = '\sProofOn '
+
+#Bug: \pVar mag entgegen der Doku keine _ mag
+REPL_UNDERSCORE	= false
+
+=begin rdoc
+Code-generator for structex, a TeX-package to create Nassi-Shneidermann diagramms.
+
+This is no subclass of Element, the initialize-method should get it's own 
+parameters.
+
+To define define ele Element-methods, module Element_methods is included.
+=end
+class Structogramm
+  
+  include Docgenerator::Element_methods #defines to_doc
+  
+	PARSTRUCT	= Struct.new('PARSTRUCT', :dir, :name, :text )
+  def self.head()
+    USEPACKAGE_STRUKTEX
+  end
+	attr_accessor :sourcecode
+=begin rdoc
+Define a structogramm.
+=end
+	def initialize( title, x, y, code = String.new )
+		@title	= title
+		@sourcecode	= code
+		@x		= x
+		@y		= y
+		@elements	= []
+    
+    @log = Log4r::Logger.new("Structogramm #{title}")
+    @log.outputters = Log4r::StdoutOutputter.new('log_stdout')
+	end
+  
+	def <<(code)
+		@sourcecode	<< code
+		@sourcecode	<< "\n"
+	end
+	#
+	#Analyse sourcecode and fill @elements
+	def analyse_sourcecode( code = @sourcecode )
+		stack	= [ @elements ]
+		lastcmd	= nil
+		code.each_line{|l|
+			l.strip!
+			case l
+			when /\A\s*#~/	#comment
+			when /\A%/
+				stack.last << l				
+			when	/ENDIF\s*(.*)/,  		/ENDCASE\s*(.*)/,
+						/ENDWHILE\s*(.*)/,	/ENDFOREVER\s*(.*)/,
+						/ENDSELECT\s*(.*)/
+				#~ @elements << "\\ifend"
+				stack.pop	#close actual IF
+				lastcmd	= nil
+			when /IF\s*(.*)/
+				#~ @elements << "\\ifthenelse{3}{3}{#{$1}}{\\pTrue}{\\pFalse}"
+				struct = Structogramm_IF.new(inline($1))
+				stack.last << struct
+				stack << struct
+				lastcmd	= nil
+			when /THEN\s*(\d)?\s*(.*)/
+				stack.last.thensize = $1 if $1
+				stack.last.thentext = inline($2) if $2 and ! $2.empty?
+				lastcmd	= nil
+			when /ELSE\s*(\d)?\s*(.*)/
+				stack.last.elsesize = $1 if $1
+				stack.last.elsetext = inline($2) if $2 and ! $2.empty?
+				#~ @elements << "\\change"
+				stack.last.else
+				lastcmd	= nil
+			when /CASE\s*(\d)?\s*(.*)/
+				struct = Structogramm_CASE.new( inline($2), $1, @log)
+				stack.last << struct
+				stack << struct
+				lastcmd	= nil
+			when /(?:SWITCH|WHEN)(?:\[([crl])\])?\s*(.*)/
+				stack.last.switch(inline($2), $1)
+				lastcmd	= nil
+			when /WHILE\s*(.*)/, /SELECT\s*(.*)/
+				struct = Structogramm_WHILE.new(inline($1))
+				stack.last << struct
+				stack << struct
+				lastcmd	= nil
+			when /REPEAT\s*(.*)/
+				struct = Structogramm_REPEAT.new(inline($1))
+				stack.last << struct
+				stack << struct
+				lastcmd	= nil
+			when /UNTIL\s*(.*)/
+				stack.last.condition = $1
+				stack.pop	#close actual IF			
+				lastcmd	= nil
+			when /FOREVER\s*(.*)/
+				struct = Structogramm_FOREVER.new()
+				stack.last << struct
+				stack << struct
+				lastcmd	= nil
+			when /<=\s*(.*)/
+				stack.last << lastcmd = Structogramm_CMD.new( "exit",		inline($1) ) 
+			when /=>\s*(.*)/
+				stack.last << lastcmd = Structogramm_CMD.new( "sub",		inline($1) ) 
+			when /<>\s*(.*)/
+				stack.last << lastcmd = Structogramm_CMD.new( "return",	inline($1) ) 
+			when /(<->|<-|->)\s*(\S+)\s*(.*)/
+				if ! lastcmd
+					@log.warn("description #{l} without command") if @log.warn?
+				else
+					lastcmd.par	<< PARSTRUCT.new($1, inline($2), $3 )
+				end
+			else
+				stack.last << lastcmd = Structogramm_CMD.new( "assign", inline(l) ) 
+			end
+		}
+	end
+	def inline( inp )
+		#~ return inp.gsub(/'(.*?)'/, '\\pKey{\1}')
+		return Document.texify(inp).gsub(/'(.*?)'/, '\\pKey{\1}').gsub(/->/, '$\to$')
+	end
+	def to_s()
+		@sourcecode
+	end
+  #Print the source code in a verbatim environmet
+	def verbatim()
+		return element(:verbatim,{},@sourcecode.gsub(/\t/, '  ')).cR
+	end
+  #
+  #Option:
+  #-:centernss Flag if the structogramm should be entered in an environment.
+	def to_latex( options = {} )
+    options = options.merge( :centernss => true )
+		analyse_sourcecode()
+		tex = [nil]
+		tex	<< '\begin{centernss}' if options[:centernss]
+		tex	<< "\\begin{struktogramm}(#{@x},#{@y})[#{@title}]"
+		tex << @elements.to_structex.map{|e|
+			#~ "\t#{e}"
+			"#{e}"
+		}
+		tex	<< '\end{struktogramm}'
+		tex	<< '\end{centernss}'		if options[:centernss]
+		tex	<< nil
+		#Gsub notwendig, da \pVar entgegen der Doku keine _ mag
+		if REPL_UNDERSCORE
+			return tex.join("\n").gsub(/_/, '\_')
+		else
+			return tex.join("\n")
+		end
+	end
+  #Return for wiki2docgenerator
+	def to_wiki( options = {} )
+    return <<xx
+>>>structogramm{#{@title};#{@x};#{@y}}
+#{@sourcecode}
+<<<    
+xx
+  end #to_wiki
+  #Return for creole2doc
+	def to_creole( options = {} )
+    return <<xx
+<<<structogramm|#{@title};#{@x};#{@y}
+#{@sourcecode}
+>>>
+xx
+  end #to_creole
+  
+  
+	#Save TEX-code
+	def save( filename, overwrite = false )
+		
+		old = nil
+		File.open( filename ){|f| old = f.readlines.to_s } if File.exists?(filename)
+		
+		if /\.nss/	=~ filename
+			new = self.to_latex(:centernss => false)
+		else
+			new = self.to_latex()
+		end
+		if old != new
+			if overwrite or old == nil
+				File.open( filename, 'w'){|f|
+					f	<< new
+				}
+				@log.INFO("Save changed #{filename}") if @log.INFO?
+			else
+				@log.info("Changed #{filename}")
+			end
+		else
+				@log.INFO("Unchanged #{filename}") if @log.INFO?
+		end
+		#~ doc = Document.new(:include)
+		#~ doc.body << self.to_tex()
+		#~ doc.save( filename, overwrite )
+	end		
+end #Structogramm
+
+
+class Structogramm_CMD
+	def initialize( type, cmd )
+		@type	= type
+		@cmd	= [ cmd ]
+		@par		= []
+	end
+	#Interface definition of command.
+	attr_reader	:par
+	#Add command... into if or else-branch
+	#~ def << (add)
+		#~ @cmd << add
+	#~ end
+	def to_structex()
+		tex = []
+		tex << "\\#{@type}{#{@cmd.join}"
+		if ! @par.empty?
+			#~ tex	<< "\\\\\\\\\n" 
+			tex	<< "\\\\\n" 
+			tex	<< interface(@par, nil)
+			#~ tex	<< interface(@par, 'Interface')
+		end
+		tex << "}"
+		return tex.join()
+	end
+	def interface( list, text )
+		return nil if list.empty?
+		interface = [ "\\begin{declaration}[#{text}]" ]
+		list.each{|par|
+			dir = nil
+			case par.dir
+				when '->';	dir = '$\\Rightarrow$'
+				when '<-';	dir = '$\\Leftarrow$'
+				when '<->';	dir = '$\\Leftrightarrow$'
+			end
+			#par.name may contain _
+			interface <<	"\\description{#{dir}\t#{par.name}}{#{par.text}}"
+		}
+		interface <<	"\\end{declaration}\n"
+		return interface.join("\n")
+	end
+	def inspect()
+		return "#<Structogramm_CMD: #{@type}>"
+		#~ return "#<IF: #{@ifstatement}>"
+	end	
+end
+
+class Structogramm_WHILE
+	def initialize( whilestatement )
+		@whilestatement = whilestatement
+		@cmd	= []
+	end
+	#Add command... into if or else-branch
+	def << (add)
+		@cmd << add
+	end
+	def to_structex()
+		tex = []
+		tex << "\\while{#{@whilestatement}}"
+		tex	<< @cmd.to_structex
+		tex << "\\whileend"
+		return tex.join("\n")
+	end
+	def inspect()
+		return "#<Structogramm_WHILE: #{@whilestatement}>"
+		#~ return "#<IF: #{@ifstatement}>"
+	end	
+end
+
+class Structogramm_REPEAT
+	def initialize( repeatstatement )
+		@condition = repeatstatement
+		@cmd	= []
+	end
+	attr_accessor :condition
+	#Add command... into if or else-branch
+	def << (add)
+		@cmd << add
+	end
+	def to_structex()
+		tex = []
+		tex << "\\until{#{@condition}}"
+		tex	<< @cmd.to_structex
+		tex << "\\untilend"
+		return tex.join("\n")
+	end
+	def inspect()
+		return "#<Structogramm_REPEAT: #{@condition}>"
+		#~ return "#<IF: #{@ifstatement}>"
+	end	
+end
+
+class Structogramm_FOREVER
+	def initialize()
+		@cmd	= []
+	end
+	#Add command... into if or else-branch
+	def << (add)
+		@cmd << add
+	end
+	def to_structex()
+		tex = []
+		tex << "\\forever"
+		tex	<< @cmd.to_structex
+		tex << "\\foreverend"
+		return tex.join("\n")
+	end
+	def inspect()
+		return "#<Structogramm_FOREVER>"
+		#~ return "#<IF: #{@ifstatement}>"
+	end	
+end
+
+class Structogramm_IF
+	def initialize( ifstatement )
+		@ifstatement = ifstatement
+		@then	= []
+		@else	= nil	#keep it empty, until method 'else' is called
+		@thentext	= '\\pTrue'
+		@elsetext	= '\\pFalse'
+		@thensize	= 3
+		@elsesize	= 3
+	end
+	#Text for 'then'-Branch. default: \pTrue
+	attr_writer	:thentext
+	#Text for 'else'-Branch
+	attr_writer	:elsetext
+	#Textwidth for 'then'-Branch
+	attr_writer	:thensize
+	#Textwidth for 'else'-Branch
+	attr_writer	:elsesize
+	#Add command... into if or else-branch
+	def << (add)
+		@else ? @else << add : @then << add
+	end
+	#Change from then-branch to else-branch
+	def else()
+		@else = []
+	end
+	def to_structex()
+		tex = []
+		tex << "\\ifthenelse{#{@thensize}}{#{@elsesize}}{#{@ifstatement}}{#{@thentext}}{#{@elsetext}}"
+		tex	<< @then.to_structex
+		tex	<< "\\change"
+		tex	<< @else.to_structex
+		tex << "\\ifend"
+		return tex.join("\n")
+	end
+	def inspect()
+		return "#<Structogramm_IF: #{@ifstatement}>"
+		#~ return "#<IF: #{@ifstatement}>"
+	end
+end
+
+class Structogramm_CASE
+	def initialize( casevar, degree = 4, log = Log4r::Logger.new('log') )
+		@casevar	= casevar
+		@degree	= degree.to_i
+		if @degree == 0
+			@log.warn("CASE #{casevar} mit degree 0") if @log.warn?
+		end
+		@cmd		= []
+		@switches	= []	#List of branches. 
+	end
+	def << (add)
+		@cmd	<< add
+	end
+	#Change branch.
+	def switch( condition, option = nil )
+		switch	= Structogramm_SWITCH.new( condition, option )
+		#The first branch is part of the \case-statement
+		@cmd		<< switch	if ! @switches.empty?
+		@switches	<< switch
+	end
+	def to_structex()
+		tex = []
+		tex << "\\case{#{@degree}}{#{@switches.size}}{#{@casevar}}{#{@switches.first.value}}"
+		tex	<< @cmd.to_structex
+		tex << "\\caseend"
+		return tex.join("\n")
+	end
+	def inspect()
+		return "#<Structogramm_CASE: #{@casestatement}>"
+		#~ return "#<IF: #{@ifstatement}>"
+	end
+end
+
+class Structogramm_SWITCH
+	def initialize( value, option )
+		@value	= value
+		@option	= option
+	end
+	attr_reader :value
+	def to_structex()
+		tex = []
+		tex << "\\switch"
+		tex << "[#{@option}]"	if @option
+		tex << "{#{@value}}"
+		return tex.join()
+	end
+	def inspect()
+		return "#<Structogramm_SWITCH: #{@value}>"
+		#~ return "#<IF: #{@ifstatement}>"
+	end
+end
+
+end #module Struktex
+end #module Packages
+end #module Docgenerator

data/lib/docgenerator/packages/todonotes.rb

@@ -0,0 +1,85 @@
+module Docgenerator
+module Packages
+=begin rdoc
+Support of the LaTeX-package todonotes.
+
+* http://ctan.org/pkg/todonotes
+=end
+module Todonotes
+=begin rdoc
+
+Example:
+  ...
+  \usepackage{todonotes}
+  ...
+  \newcommand{\addref}{\todo[color=red!40]{Addreference.}}
+  \newcommand{\rewrite}[1]{\todo[color=green!40]{#1}}
+  ...
+  % ----------------------------------------------------------------
+  \begin{document}
+  \blindtext\todo{AAA}\todo{BBB}\todo{CCC}\blindtext
+
+  \blindtext\todo{AAA}\todo[color=yellow]{BBB}\todo[color=green]{CCC}\blindtext
+
+  \blindtext\todo[inline]{AAA}\blindtext
+=end
+class Todo < Element
+  
+  add_attributes( {
+      #~ disable The disable option can be given directly to the todo command. If given the command has no effect.
+			:color		=>	Attribute.create( [ :texkeyval], [ String ] ),
+			:backgroundcolor =>	Attribute.create( [ :texkeyval], [ String ] ),
+			:linecolor		=>	Attribute.create( [ :texkeyval], [ String ] ),
+			:bordercolor		=>	Attribute.create( [ :texkeyval], [ String ] ),
+			:inline		=>	Attribute.create( [ :texkeyval], [ true, false ] ),
+=begin      
+    more options:
+      line / noline
+      inline / noinline
+      size
+      list / nolist When the option nolist is given, the todo item will not appear in the list of todos.
+      caption For listoftodos
+=end
+    }#.update(HTML_ATTR_ALL)
+    )
+    
+  add_output( :latex,  '#{linebreak(@crbefore)}\todo[#{texkeyval()}]{#{@content}}#{linebreak(@crafter)}')
+
+  def self.head()
+    element(:usepackage, {}, 'todonotes').cr
+  end
+end #Todonotes::Todo
+
+
+=begin rdoc
+Define Element :missingfigure
+
+Create an instance with
+  element( :missingfigure, [ attributes, [content]] )
+or
+  Missingfigure.new( [ attributes, [content]] )
+Attributes may be:
+* :figwidth: 
+=end
+class Missingfigure < Element
+  add_attribute :figwidth, Attribute.create([:texkeyval], [Integer, String]  )  #String for \textwidth... for HTML use CSS
+  add_latex_output '\missingfigure{#{@content}}'
+end #Missingfigure
+
+=begin rdoc
+Define Element :listoftodos
+
+Create an instance with
+  element( :listoftodos, [ attributes, [content]] )
+or
+  Listoftodos.new( [ attributes, [content]] )
+Attributes are not defined for this element.
+=end
+class Listoftodos < Element
+  has_no_content false
+  add_latex_output '\listoftodos'
+end #Listoftodos
+
+end #module Todonotes
+end #module Packages
+end #Docgenerator