wortsammler 0.0.9 → 1.0.0

data/lib/wortsammler/class.Traceable.md.rb

@@ -11,98 +11,98 @@ Treetop.load File.dirname(__FILE__) + "/mdTraceParser.treetop"
 
 
 class TraceableSet
-    
-
-
-    # this generates a synopsis of traces in markdown Format
-    # @param [Symbol] selectedCategory the the category of the Traceables
-    #                 which shall be reported.
-    def reqtraceSynopsis(selectedCategory)
-        all_traces(selectedCategory).
-            sort_by{|x| trace_order_index(x.id) }.
-            map{|t|
-                 tidm=t.id.gsub("_","-")
-    
-                 lContributes=t.contributes_to.
-    #                  map{|c| cm=c.gsub("_","-"); "[\[#{c}\]](#RT-#{cm})"}
-                       map{|c| cm=c.gsub("_","-"); "<a href=\"#RT-#{cm}\">\[#{c}\]</a>"}
-                       
-                   luptraces = [uptrace_ids[t.id]].flatten.compact.map{|x| self[x]}
-                   
-                   luptraces=luptraces.
-                       sort_by{|x| trace_order_index(x.id)}.            
-                       map{|u|
-                       um = u.id.gsub("_","-")
-                       "    - <a href=\"#RT-#{um}\">[#{u.id}]</a> #{u.header_orig}"
-                       }      
-    
-                 ["- ->[#{t.id}] <!-- --> <a id=\"RT-#{tidm}\"/>**#{t.header_orig}**" +
-    #                     "  (#{t.contributes_to.join(', ')})", "",
-                          "  (#{lContributes.join(', ')})", "",
-                          luptraces
-                ].flatten.join("\n")
-            }.join("\n\n")
-    end
 
 
-    # this generates the downstream_tracefile
-    def to_downstream_tracefile(selectedCategory)
-         all_traces(selectedCategory).
-            sort_by{|x| trace_order_index(x.id) }.
-            map{|t|
-                 "\n\n[#{t.id}] **#{t.header_orig}** { }()"
-               }.join("\n\n")
-    end
 
-    # 
-
-    # This factory method processes all traces in a particular markdown file
-    # and returns a TraceableSet
-    # 
-
-    # @param  mdFile [String] name of the markdown File which shall be scanned
-
-    # 
-
-    # @return [TraceableSet] The set of traceables found in the markdown file
-    def self.processTracesInMdFile(mdFile)
-        
-        parser=TraceInMarkdownParser.new
-        parser.consume_all_input = true
-        
-        raw_md_code_file=File.open(mdFile, "r:bom|utf-8")
-        raw_md_code = raw_md_code_file.readlines.join
-        raw_md_code_file.close
-#       print mdFile
-        result = parser.parse(raw_md_code)
-#       print " ... parsed\n" todo: use logger here
-        
-        result_set = TraceableSet.new
-
-        if result
-            result.descendant.select{|x| x.getLabel==="trace"}.each{|c|
-                id       = c.traceId.payload.text_value
-                uptraces = c.uptraces.payload.text_value
-                header   = c.traceHead.payload.text_value
-                bodytext = c.traceBody.payload.text_value
-                uptraces = c.uptraces.payload.text_value
-                # Populate the Traceable entry
-                theTrace = Traceable.new
-                theTrace.info           = mdFile
-                theTrace.id             = id
-                theTrace.header_orig    = header
-                theTrace.body_orig      = bodytext
-                theTrace.trace_orig     = c.text_value
-                theTrace.contributes_to = uptraces.gsub!(/\s*/, "").split(",")
-                theTrace.category       = :SPECIFICATION_ITEM
-                result_set.add(theTrace)
-            }
-#            puts " .... finished"
-            else
-            puts ["","-----------", texFile, parser.failure_reason].join("\n")
-        end
-        result_set
+  # this generates a synopsis of traces in markdown Format
+  # @param [Symbol] selectedCategory the the category of the Traceables
+  #                 which shall be reported.
+  def reqtraceSynopsis(selectedCategory)
+    all_traces(selectedCategory).
+      sort_by{|x| trace_order_index(x.id) }.
+    map{|t|
+      tidm=t.id.gsub("_","-")
+
+      lContributes=t.contributes_to.
+      #                  map{|c| cm=c.gsub("_","-"); "[\[#{c}\]](#RT-#{cm})"}
+      map{|c| cm=c.gsub("_","-"); "<a href=\"#RT-#{cm}\">\[#{c}\]</a>"}
+
+      luptraces = [uptrace_ids[t.id]].flatten.compact.map{|x| self[x]}
+
+      luptraces=luptraces.
+      sort_by{|x| trace_order_index(x.id)}.
+      map{|u|
+        um = u.id.gsub("_","-")
+        "    - <a href=\"#RT-#{um}\">[#{u.id}]</a> #{u.header_orig}"
+      }
+
+      ["- ->[#{t.id}] <!-- --> <a id=\"RT-#{tidm}\"/>**#{t.header_orig}**" +
+       #                     "  (#{t.contributes_to.join(', ')})", "",
+       "  (#{lContributes.join(', ')})", "",
+       luptraces
+       ].flatten.join("\n")
+    }.join("\n\n")
+  end
+
+
+  # this generates the downstream_tracefile
+  def to_downstream_tracefile(selectedCategory)
+    all_traces(selectedCategory).
+      sort_by{|x| trace_order_index(x.id) }.
+    map{|t|
+      "\n\n[#{t.id}] **#{t.header_orig}** { }()"
+    }.join("\n\n")
+  end
+
+  #
+
+  # This factory method processes all traces in a particular markdown file
+  # and returns a TraceableSet
+  #
+
+  # @param  mdFile [String] name of the markdown File which shall be scanned
+
+  #
+
+  # @return [TraceableSet] The set of traceables found in the markdown file
+  def self.processTracesInMdFile(mdFile)
+
+    parser=TraceInMarkdownParser.new
+    parser.consume_all_input = true
+
+    raw_md_code_file=File.open(mdFile, "r:bom|utf-8")
+    raw_md_code = raw_md_code_file.readlines.join
+    raw_md_code_file.close
+    #       print mdFile
+    result = parser.parse(raw_md_code)
+    #       print " ... parsed\n" todo: use logger here
+
+    result_set = TraceableSet.new
+
+    if result
+      result.descendant.select{|x| x.getLabel==="trace"}.each{|c|
+        id       = c.traceId.payload.text_value
+        uptraces = c.uptraces.payload.text_value
+        header   = c.traceHead.payload.text_value
+        bodytext = c.traceBody.payload.text_value
+        uptraces = c.uptraces.payload.text_value
+        # Populate the Traceable entry
+        theTrace = Traceable.new
+        theTrace.info           = mdFile
+        theTrace.id             = id
+        theTrace.header_orig    = header
+        theTrace.body_orig      = bodytext
+        theTrace.trace_orig     = c.text_value
+        theTrace.contributes_to = uptraces.gsub!(/\s*/, "").split(",")
+        theTrace.category       = :SPECIFICATION_ITEM
+        result_set.add(theTrace)
+      }
+      #            puts " .... finished"
+    else
+      puts ["","-----------", texFile, parser.failure_reason].join("\n")
     end
+    result_set
+  end
+
 
-    
-end
+end

data/lib/wortsammler/class.Traceable.rb

@@ -43,6 +43,8 @@ class TraceableSet
   #    * second
   #
   # @return [type] [description]
+  #
+  #
   def add(traceable)
     #TOOD: check traceable
     #TODO: check if append can be optimized
@@ -284,7 +286,7 @@ class TraceableSet
   # @param [Nokogiri::XML::Document] doc - the document
   # @return [Nokogiri::XML::Document] the beautified document
   def xp(doc)
-    xsl =<<XSL
+    xsl =<<-XSL
     <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
     <xsl:output method="xml" encoding="UTF-8" indent="yes"/>
     <xsl:strip-space elements="*"/>
@@ -292,7 +294,7 @@ class TraceableSet
     <xsl:copy-of select="."/>
     </xsl:template>
     </xsl:stylesheet>
-XSL
+    XSL
 
 
     xslt = Nokogiri::XSLT(xsl)

data/lib/wortsammler/class.proolib.rb

@@ -17,6 +17,8 @@ require 'tmpdir'
 require 'nokogiri'
 require "rubyXL"
 require 'logger'
+require 'wortsammler/latex_helper'
+
 
 Encoding.default_external = Encoding::UTF_8
 Encoding.default_internal = Encoding::UTF_8
@@ -822,13 +824,14 @@ class PandocBeautifier
     tempfile     = input
     tempfilePdf  = "#{@tempdir}/x.TeX.md".to_osPath
     tempfileHtml = "#{@tempdir}/x.html.md".to_osPath
-    outfilePdf   = "#{outdir}/#{outname}.pdf".to_osPath
-    outfileDocx  = "#{outdir}/#{outname}.docx".to_osPath
-    outfileHtml  = "#{outdir}/#{outname}.html".to_osPath
-    outfileRtf   = "#{outdir}/#{outname}.rtf".to_osPath
-    outfileLatex = "#{outdir}/#{outname}.latex".to_osPath
-    outfileText  = "#{outdir}/#{outname}.txt".to_osPath
-    outfileSlide = "#{outdir}/#{outname}.slide.html".to_osPath
+    outfile      = "#{outdir}/#{outname}".to_osPath
+    outfilePdf   = "#{outfile}.pdf"
+    outfileDocx  = "#{outfile}.docx"
+    outfileHtml  = "#{outfile}.html"
+    outfileRtf   = "#{outfile}.rtf"
+    outfileLatex = "#{outfile}.latex"
+    outfileText  = "#{outfile}.txt"
+    outfileSlide = "#{outfile}.slide.html"
 
     if vars.has_key? :frontmatter
       latexTitleInclude = "--include-before-body=#{vars[:frontmatter].esc}"
@@ -871,7 +874,6 @@ class PandocBeautifier
 
     begin
 
-
       if format.include?("frontmatter") then
 
         ReferenceTweaker.new("pdf").prepareFile(tempfile, tempfilePdf)
@@ -880,15 +882,8 @@ class PandocBeautifier
         `#{cmd}`
       end
 
-      if format.include?("pdf") then
-        @log.debug("creating  #{outfilePdf}")
-        ReferenceTweaker.new("pdf").prepareFile(tempfile, tempfilePdf)
-        cmd="pandoc -S #{tempfilePdf.esc} #{toc} --standalone #{option_chapters} --latex-engine xelatex --number-sections #{vars_string}" +
-          " --template #{latexStyleFile.esc} --ascii -o  #{outfilePdf.esc} #{latexTitleInclude}"
-        `#{cmd}`
-      end
 
-      if format.include?("latex") then
+      if (format.include?("pdf") | format.include?("latex")) then
         @log.debug("creating  #{outfileLatex}")
         ReferenceTweaker.new("pdf").prepareFile(tempfile, tempfilePdf)
 
@@ -897,6 +892,32 @@ class PandocBeautifier
         `#{cmd}`
       end
 
+
+      if format.include?("pdf") then
+        @log.debug("creating  #{outfilePdf}")
+        ReferenceTweaker.new("pdf").prepareFile(tempfile, tempfilePdf)
+        #cmd="pandoc -S #{tempfilePdf.esc} #{toc} --standalone #{option_chapters} --latex-engine xelatex --number-sections #{vars_string}" +
+        #  " --template #{latexStyleFile.esc} --ascii -o  #{outfilePdf.esc} #{latexTitleInclude}"
+        cmd="xelatex -halt-on-error -interaction nonstopmode -output-directory=#{outdir.esc} #{outfileLatex.esc}"
+        #cmdmkindex = "makeindex \"#{outfile.esc}.idx\""
+
+        latex=LatexHelper.new.set_latex_command(cmd).setlogger(@log)
+        latex.run(outfileLatex)
+
+        messages=latex.log_analyze("#{outdir}/#{outname}.log")
+
+        removeables = ["toc", "aux", "bak", "idx", "ilg", "ind" ]
+        removeables << "log" unless messages > 0
+
+
+        removeables << "latex" unless format.include?("latex")
+        removeables = removeables.map{|e| "#{outdir}/#{outname}.#{e}"}.select{|f| File.exists?(f)}
+        removeables.each{|e| 
+          @log.debug "removing file: #{e}"
+          FileUtils.rm e
+        }
+      end      
+
       if format.include?("html") then
         #todo: handle css
         @log.debug("creating  #{outfileHtml}")
@@ -951,7 +972,8 @@ class PandocBeautifier
         `#{cmd}`
       end
     rescue Exception => e
-      @log.error "failed to perform #{cmd}, #{e.message}"
+      @log.error "failed to perform #{cmd}, \n#{e.message}"
+      @log.error e.backtrace.join("\n")
       #TODO make a try catch block kere
     end
     nil

data/lib/wortsammler/exe.wortsammler.rb

@@ -46,11 +46,12 @@ optparse = OptionParser.new do|opts|
   opts.on( "-v", '--version', 'print Version info, then turn on verbose mode' ) do
     options[:version] = true
     options[:verbose] = true
+    $log.level=Logger::DEBUG
   end
 
   opts.separator nil
 
-  options[:init] = false
+  options[:init] = nil
   opts.on( "-n", '--init DIR', 'create a project folder in DIR' ) do|file|
     options[:init] = file
   end
@@ -58,12 +59,12 @@ optparse = OptionParser.new do|opts|
 
   opts.separator nil
 
-  options[:inputpath] = false
+  options[:inputpath] = nil
   opts.on( '-i', '--inputpath PATH', 'set input file/project folder for processing') do|path|
     options[:inputpath] = path
   end
 
-  options[:manifest] = false
+  options[:manifest] = nil
   opts.on( '-m', '--manifest PATH', 'set mainfest file for processing' ) do|file|
     options[:manifest] = file
   end
@@ -75,7 +76,7 @@ optparse = OptionParser.new do|opts|
     options[:outputformats] = formatlist
   end
 
-  options[:outputfolder] = false
+  options[:outputfolder] = nil
   opts.on( '-o', '--outputfolder PATH', 'set the output to PATH' ) do|path|
     options[:outputfolder] = path
   end
@@ -120,6 +121,5 @@ rescue RegexpError => error
   exit
 end
 
-
 Wortsammler.verify_options(options)
 Wortsammler.execute(options)

data/lib/wortsammler/latex_helper.rb

@@ -0,0 +1,244 @@
+# a=LatexHelper.new.set_command(cmd).setlogger(log).
+
+class LatexHelper
+
+  attr_accessor :latex_result, :mkindex_result
+
+  @latex_command = nil
+  @latex_result=nil
+  @mkindex_result=nil
+  @log=nil
+
+
+
+  #
+  # [initialize description]
+  #
+  # @return [type] [description]
+  def initialize()
+  end
+
+  def setlogger(log)
+    @log=log
+    return self
+  end
+
+
+
+  #
+  # [set_latex_command description]
+  # @param  cmd [type] [description]
+  #
+  # @return [type] [description]
+  def set_latex_command(cmd)
+    @latex_command=cmd
+    return self
+  end
+
+
+  #
+  # [run_latex description]
+  #
+  # @return [type] [description]
+  def run_latex()
+    @latex_result = `#{@latex_command}`
+    return self
+  end
+
+  #
+  # [run_mkindex description]
+  # @param  outfile [type] [description]
+  #
+  # @return [type] [description]
+  def run_mkindex(outfile)
+    outfilename=File.basename(outfile, ".*")
+    indexinfile="#{outfilename}.idx"
+    indexlogfile="#{outfilename}.ilg"
+    indexoutfile="#{outfilename}.ind"
+
+    current_dir = FileUtils.pwd
+    FileUtils.cd(File.dirname(outfile)) do |mydir|
+      @mkindex_result=nil
+      if File.exist?(indexinfile) then
+        a=`makeindex -q #{indexinfile.esc} 2>&1`
+        @mkindex_result=ilg_analyse(indexlogfile)
+      end
+    end
+
+    return self
+  end
+
+
+  #
+  # [add_sort_key description]
+  # @param  indexinfile [type] [description]
+  #
+  # @return [type] [description]
+  def add_sort_key(indexinfile)
+    content=File.open(indexinfile, "r").read
+    content.gsub!(/\\indexentry{([^\}]*)}/){|entry|
+      reference=$1.split("|").first
+      originalterms=reference.split("!")
+      newterms=originalterms.map{|ot|
+
+        sortterm=ot.clone
+        sortterm.gsub!('Ä', "ae")
+        sortterm.gsub!('ä', "ae")
+        sortterm.gsub!('Ö', "oe")
+        sortterm.gsub!('ö', "oe")
+        sortterm.gsub!('Ü', "ue")
+        sortterm.gsub!('ü', "ue")
+        sortterm.gsub!('ß', "ss")
+        nt=ot
+        nt="#{sortterm}@#{ot}" unless sortterm.include?("@")
+      }.join("!")
+      #      	require 'pry';binding.pry
+
+      entry.gsub(reference, newterms)
+    }
+
+    File.open(indexinfile, "w") do |f|
+      f.puts(content)
+    end
+  end
+
+  #
+  # [run description]
+  # @param  outfile [type] [description]
+  #
+  # @return [type] [description]
+  def run(outfile)
+
+    reruncount=3
+
+    run_latex()
+    run_mkindex(outfile)
+
+    while need_rerun? && ((reruncount-=1) >0)
+      run_latex()
+      run_mkindex(outfile)
+    end
+  end
+
+
+  #
+  # [need_rerun? description]
+  #
+  # @return [type] [description]
+  def need_rerun?()
+    @latex_result.include?("Rerun to get")
+    true
+  end
+
+
+  #
+  # [ilg_analyse description]
+  # @param  logfilename [type] [description]
+  #
+  # @return [type] [description]
+  def ilg_analyse(logfilename)
+    stat = {}
+    error = nil
+    File.readlines(logfilename).each{ |logline|
+      if error  #Index error announced in previous line
+        ( stat[:errors] ||= [] ) << "#{logline.chomp.sub(/.*--/, "")} #{error}"
+        error = nil
+      else
+        case logline
+        when /Scanning input file (.*)\...done \((.*) entries accepted, (.*) rejected\)./
+          #~ stat[:source_information] ||= [] << "input file #{$1} (#{$2} entries accepted, #{$3} rejected)"
+          stat[:source_information] ||= []
+          stat[:source_information] << "Input file: #{$1}"
+          stat[:source_information] << "Entries accepted: #{$2}"
+          stat[:source_information] << "Entries rejected: #{$3}"
+          #~ when /done \((.*) entries accepted, (.*) rejected\)./
+          #~ result[:rejected] += $2.to_i() if $2.to_i() > 0
+        when /!! Input index error \(file = (.*), line = (.*)\):/
+          #Error-message on next line
+          error = "(file #{$1} line #{$2}: #{logline})"
+        end
+      end #if error
+    }
+    stat
+  end
+
+
+  # 
+  # This analyzes the latex log file thereby filters warenings and errors
+  # @param  logfilename [String] The filename of the log
+  # 
+  # @return [Nil] no return
+  def log_analyze(logfilename)
+    result = {
+      errors: 0,
+      warings: 0,
+      loglines: []
+    }
+
+    outCounter = 0
+    lineCounter = 0
+    errorCounter = 0
+    warningCounter = 0
+    previousLine = ""
+
+    logfilename_reported = File.basename(logfilename)
+
+    File.readlines(logfilename).each{ |l|
+      logline = l.strip
+      lineCounter += 1
+
+
+      if logline =~ /Output written on/ then
+        outCounter = 5
+      end
+
+      if logline =~ /Running / then
+        lineCounter = 0
+      end
+
+      if logline =~ /Buffer size exceeded/ then
+        lineCounter = 0
+        @log.error ("\n!Error Buffer size exceeded, for details see line #{lineCounter} #{logfilename_reported}")
+        @log.info previousLine
+        errorCounter += 1
+        outCounter=5
+      end
+
+      if logline =~ /^!/ then
+        lineCounter = 0
+        @log.error ("LaTeX error; for details see line #{lineCounter} #{logfilename_reported}")
+        errorCounter += 1
+        outCounter=5
+      end
+
+      if logline =~ /\[ INFO\]/ then
+        $log.info logline
+      end
+
+      if logline =~ /Warning:|pdfTeX warning/ then
+        $log.warn "for details see line #{lineCounter} #{logfilename_reported}"
+        warningCounter += 1
+        outCounter = 5
+      end
+
+      if logline =~ /^(Underfull|Overfull)/  then
+        outCounter = 0
+      end
+
+      if (outCounter > 0) then
+        $log.info logline
+        outCounter -= 1
+
+        if outCounter == 0 then
+          $log.info ""
+        end
+      end
+    }
+
+    @log.info ("logfilter: errors   = #{errorCounter}")
+    @log.info ("logfilter: warnings = #{warningCounter}")
+
+    errorCounter + warningCounter
+  end
+
+end

data/lib/wortsammler/version.rb

@@ -1,4 +1,4 @@
 module Wortsammler
   PROGNAME="wortsammler"
-  VERSION = "0.0.9"
+  VERSION = "1.0.0"
 end