docgenerator 0.1.1

data/docgenerator_document.rb

@@ -0,0 +1,374 @@
+#
+#Container for a document.
+#
+#Each document contains a header and a body. Both are special Element classes.
+#
+class Document
+	#Create a new document.
+	#There are different document templates supported. 
+	#The templates refer to the corresponding TeX-classes.
+	#-	article
+	#-	report
+	#-	book
+	def initialize( template = nil )
+		#Set template defaults
+		@template	= {
+			:html	=> DocumentTemplate[:html],
+			:latex	=> DocumentTemplate[:article],
+			:text		=> DocumentTemplate[:text],
+			:wiki		=> DocumentTemplate[:wiki],
+		}
+		self.set_template( template ) if template
+		@body	= element( :body )
+		@head	= element( :head )
+		#~ @body.part_of << self
+		#~ @head.part_of << self
+		@body.part_of_doc << self
+		@head.part_of_doc << self
+		@language	= 'ngerman'
+		@options	= []
+		@meta	= {}	#some meta-Tags for HTML
+    #Flag to avoid double definition of docinfo()
+    @docinfo_called = false
+    @creator  = nil
+	end
+	#
+	#Set Template to Generate a target.
+	#
+	#Compatibility for old version:
+	#-If template is an array, each entry is used as a key for DocumentTemplate.
+	#
+	def set_template( template, target = :latex )
+		template = [ template ] if template.kind_of?( Symbol )
+		#Compatibility for older version: Template can be given direct
+		if template.kind_of?(String )
+			#~ puts "Set Template with string"
+			@template[target] = template
+			return
+		elsif template.kind_of?(Array )
+			template.each{|templ|
+				if SUPPORTED_LaTeX_TEMPLATES.include?( templ )
+					target = :latex
+				elsif SUPPORTED_HTML_TEMPLATES.include?( templ )
+					target = :html
+				elsif /text/ =~ templ.to_s or /txt/ =~ templ.to_s
+					target = :txt
+				else
+					puts "Unknown template conversion for #{templ}"
+					target = :latex
+				end
+				@template[target] = DocumentTemplate[templ]
+				if ! @template[target]
+					puts "Unknown template #{templ}, valid:\n\t#{DocumentTemplate.keys.join("\n\t")}"	#fixme raise
+				elsif ! @template[target].kind_of?(String )
+					puts "Template no string #{@template.inspect}"
+					@template[target] = @template[target].to_s
+				end
+			}
+		else
+			raise "Should set template, but don't know how #{template.inspect}"		
+		end
+	end
+	#body and head are lists, containing elements.
+	attr_reader	:body, :head
+	attr_reader	:template
+	#Document title
+	attr_accessor	:title
+	#Set document description
+	attr_writer	:author, :date, :keywords, :description, :creator
+	attr_writer	:language
+	#Flag, if tex should be started immediate after document creation.
+	attr_writer	:runtex
+	#Add more keywords
+	def keyword_add( keyword )
+		@keywords << ", #{keyword}"
+	end
+
+	#Constant to detect the generated header
+	PREFIX_ENDFLAG = 'Generation-Info-End'
+	#
+	#Define, if there should be a message in case of:
+	#-:change	Document changed
+	#-:nochange	Document existed, but is unchanged
+	#Give an array with the wanted values.
+	def Document.givemessage=( value = [:change, :nochange] )
+		@@givemessage = value
+	end
+	@@givemessage = [:change, :nochange]
+	def Document.givemessage();	@@givemessage;	end
+	#Add a meta-tag-information for the HTML-Output.
+	def meta( key, content )
+		key	= key.to_s
+		if @meta[key]
+			puts "Double definition meta-tag #{key} (old: #{@meta[key]}, new: #{content})"
+		end
+		@meta[key] = content
+	end
+	#Prepare the docinfo.
+	#May be called only once.
+	#
+	#If the title should change (e.g. when you save the document twice in different versions)
+	#you can do it via the parameter.
+	def docinfo()
+		#If this method is called twice (e.g. with save to tex and html),
+		#then the title is doubled in the second output.
+		#(Elements are added to @head)
+		return nil if @docinfo_called
+		@docinfo_called = true
+		
+		#Build docinfo.
+		result = []
+		result << element( :title, {:short => @meta["shorttitle"] }, @title).CR if @title
+		result << element( :author, {}, @author).cr if @author
+		result << element( :date, {}, @date).cr if @date
+		result << element( :keywords, {}, @keywords).cr if @keywords
+		result << element( :metadescription, {}, @description).cr if @description
+		result << element( :creator, {}, @creator).cr if @creator
+		@meta.each{ |key, content|
+			result << element( :meta, { :name => key, :content => content } ).cr
+		}
+		return result
+	end
+	def add_option( option)
+		@options << option
+	end
+	#Prepare a table of content.
+	#More or less a test.
+	#Use it for element :tableofcontents?
+	def toc()
+		toc = []
+		toccnt	= 0
+		#~ toc = element(:ul).cR
+		toc_ids = [ :chapter, :section,:subsection, :subsubsection, :paragraph, :subparagraph,:minisec]
+		@body.content.flatten.each{|el|
+			depth = toc_ids.index((el.ids & toc_ids)[0])
+			#~ puts "#{depth.inspect}\t#{el.content}"
+			if el[:id].content.empty?
+				el[:id] << "toc#{toccnt += 1}"
+			end
+			if depth
+				#~ toc << element(:li,{},[ el.content])
+				toc << element(:a, {:href => "#{el[:id]}" }, [ '*' * depth, el.content ])
+				toc << element(:br).cr
+			end		
+		}
+		return toc
+	end
+	#Save the file.
+	#The type of the document is determined by the file extensison.
+	#Supported document types are:
+	#-	tex
+	#-	html
+	#Depending on a template, different results are created.
+	#
+	#The is a comparison between an already existing file and the new one.
+	#To write a new version, the document must change and overwrite must be true.
+	#
+	#It is possible to give pairs of RegExp (pattern) and replacements to the result.
+	def save( filename, overwrite=false, replacements = {}  )
+	
+		if ! @template
+			puts "No template available to create #{filename}"
+			return false
+		end
+		
+		old = nil
+		prefix = [ 	nil, 
+				"Build by\t#{__FILE__}",
+				"Dir:\t\t#{Dir.pwd}",
+				"Creator:\t#{$0}",
+				"Target:\t\t#{filename}",
+				"#{Time.now.strftime('%Y/%m/%d %H:%M:%S')}",
+				nil,
+				"#{PREFIX_ENDFLAG}"
+			].join("\n\t")
+		if File.exist?( filename )
+			f = File.new( filename )
+			old = f.readlines().to_s
+			f.close
+		end
+		#Determine the target document type, depending on extension.
+		extension = File.basename( filename ).split( /\./).last
+		case extension
+		when /tex/i
+			@target	= :latex
+		when /htm[l]?/i
+			@target	= :html
+		when /txt/
+			@target	= :text
+		when /wiki/
+			@target = :wiki
+		else
+			raise "Unknown Extension #{extension}"
+		end
+		
+		@@target = @target	if ! UNDER_CONSTRUCTION
+		new = to_element( @target, @template[@target], replacements )
+		
+		case @target
+		when :latex
+			prefix.gsub!( /^/, '%' )
+			old.sub!(/\A.*#{PREFIX_ENDFLAG}/m, '<<prefix>>' ) if old
+		when :html
+			#Delete prefix (with generation time) for later compare.
+			old.sub!(/\A.*#{PREFIX_ENDFLAG}/m, "<!--\n<<prefix>>" ) if old
+		when :text
+		when :wiki
+			#~ new.squeeze!("\n")
+		else
+			raise "Unknown target #{@target}"
+		end
+		#Make it a bit more compact.
+		#TeX requires at least 2 \n for paragraph changes
+		new.gsub!(/\n+\n\n/, "\n\n")
+		
+		if ! new.kind_of?( String )
+			puts "New is wrong type: #{new.inspect}"
+		end
+		@target	= nil
+
+		if new != old
+			new.sub!( '<<prefix>>',	prefix)
+			if ( File.exist?( filename ) and !overwrite )
+				puts "Datei #{filename} exist already \nContinue [yn]?"
+				answer = $stdin.gets()	if $stdin.tty? #nur bei call aus DOS-Box
+				if ! ( answer =~ /[YyjJ].*/ )
+					puts "Bye"
+					return false
+				end
+			end	
+			f = File.new( filename, 'w' )
+			f << new
+			f.close
+			puts "Save changed\t#{filename}"	if @@givemessage.include?(:change)
+			#Save copy of old version (attention, *.bak makes no control on tex or html)
+			#~ f = File.new( filename.sub( extension, 'bak'), 'w' )
+			#~ f << old
+			#~ f.close
+			Document.runtex( filename, @runtex ) if @runtex
+			return true
+		elsif old
+			puts "Unchanged\t#{filename}" if @@givemessage.include?(:nochange)
+			return false
+		end		
+	end
+	#Build the content for the target format.
+	#Supported tagret formats are:
+	#-	:latex
+	#-	:html
+	#-	:text
+	#If the standard templates are used, there is a <<prefix>> left 
+	#(used from Document#save to include some additional information).
+	#
+	#If the method is called directly to prpare document snipplets, you can use:
+	#	puts Document#to_element( :latex, '<<body>>')
+	#
+	#It is possible to give pairs of RegExp (pattern) and a replacement to the result.
+	def to_element( target, template=@template[target], replacements = {} )
+	
+		@@target = target	if ! UNDER_CONSTRUCTION
+		if ! template
+			puts "No template available to create #{target.inspect} #{self.class}"
+			return ''
+		end
+		
+		new = template.dup
+		case target
+		when :latex
+			add_option( @language )
+		when :html
+		when :text
+		when :wiki
+		else
+			raise "Unknown Extension #{extension}"
+		end
+		if ! new.kind_of?( String )
+			puts "New is wrong type: #{new.inspect}"
+		end
+
+		@head	<< self.docinfo()
+		new.sub!( '<<head>>',	@head.to_s)
+		new.sub!( '<<body>>',	@body.to_s)
+		new.sub!( '<<classoptions>>',	@options.join(','))
+		
+		replacements.each{|pattern, replace |
+			new.gsub!( pattern, replace ) if replace
+		}
+		return new
+	end	#Document#to_element	
+	#Return the actual target type.
+	#Needed by Element#to_s to decide which method is used to prepare the output.
+	#
+	#The usage of this technic makes similar processing unposibble.
+	#Set in Document#save.
+	attr_reader :target
+	@@target	= nil
+	#Set a major output routine.
+	def Document.target=( target )
+		@@target = target
+	end
+	def Document.target( element )
+		return @@target if @@target	#Use global value for multiple outputs
+		case element.part_of_doc.size
+		when 1
+			return element.part_of_doc.first.target
+		when 0
+			puts "Document.target: No related document. Don't know which target to take #{element.inspect} line #{__LINE__}"
+			element.ancestors.flatten.each_with_index{|a,i|
+				puts "\tAncestor #{i}\t#{a.inspect}"
+				puts "\t\t\t#{a.ancestors.inspect}"
+			}
+			#~ puts caller()
+			return :text
+		else
+			puts "Multiple documents. Don't know which target to take #{element.inspect}"
+			element.part_of_doc.each{|d|	puts "\t#{d.inspect}" }
+			return :text
+		end
+	end
+	#Call TeX and translate the file.
+	#Experimental
+	#Fixme: Chain
+	def Document.runtex( filename, format = :pdflatex )
+		begin
+			#~ require 'rtex'
+			require 'c:/usr/script/rtex/rtex'
+		rescue LoadError
+			puts "Sorry, didn't find the experimental tex translation tool to translate #{filename}"
+			return false
+		end
+		#~ puts "Unknown texfile #{filename}" if ! filename
+		tex = Chain.new()
+		case format
+		when :latex
+			tex.latex()
+		end
+		#~ Logger.level=3
+		tex.file = filename
+		begin
+			tex.execute()
+		rescue SystemExit
+			puts "rescued a SystemExit exception"
+			return false
+		end
+	end
+	#Make some basic replacemnts for TeX.
+	#There is no sense to use it with HTML.
+	#
+	#Better solution: Puts String into \path, \verb or similar.
+	def Document.texify( input )
+		out = input.strip
+		#~ out.gsub!( /&/, '\\\&')	#geht schief. erzeugt <<body>>...
+		#~ out.gsub!( /\\/, '\\\\')
+		out.gsub!( /%/, '\%')
+		out.gsub!( /\$/, '\$')
+		out.gsub!( /&/, '\\\\&')
+		out.gsub!( /_/, '\_')
+		out.gsub!( /�/, '\euro ')
+		return out
+	end
+	def inspect()
+		return "#<Document '#{@title}'>"
+		#~ return "#<Document '#{@title} #{@body.inspect}>'"
+	end
+end	#Document