wortsammler 0.0.2

data/lib/wortsammler/class.treetopHelper.rb

@@ -0,0 +1,117 @@
+
+#
+# this mixin provides a convenient interface
+# for the syntaxtree
+#
+
+class Treetop::Runtime::SyntaxNode
+    
+    # this delivers a child node of the AST
+    def child
+        elements.select{|e| e.is_ast?} if ! elements.nil?
+    end
+    
+    # returns an array of all descendants of the current node
+    # in the AST in document order
+    def descendant
+        child.map{|e| [e, e.descendant]}.flatten.compact if not child.nil?
+    end
+    
+    # returns this and all descendant in document order
+    def thisdescendant
+        [self, descendant].flatten
+    end
+    
+    # returns all nodes to up to the AST root
+    def ancestor
+        if ! parent.nil?
+            [parent, parent.ancestor].flatten
+        end
+    end
+    
+    # indicates if the current treetop node is important enough
+    # to be in the intended AST
+    def is_ast?
+        true # nonterminal? # parent.nil? or extension_modules.include?(Xmine)
+    end
+    
+    # indicates if a meaningful name for the node in the AST
+    # is available
+    def has_rule_name?
+        not (extension_modules.nil? or extension_modules.empty?)
+    end
+    
+    # returns a meaning name for the node in the AST
+    def rule_name
+        if has_rule_name? then
+            extension_modules.first.name.split("::").last.gsub(/[0-9]/,"")
+            else
+            "###"
+        end
+    end
+    
+    # another quick info for a node
+    def to_info
+        rule_name + ": "+ text_value
+    end
+    
+    # exposes a node in the AST as xml
+    def to_xml
+        if child.nil? or child.empty?
+            "#>" +interval.to_s + ":"+ text_value + "<#"
+            else
+            [  xml_start_tag,
+            (child.nil? ? [] : child).map{|x| x.to_xml},
+            xml_end_tag
+            ].join
+        end
+    end
+    
+    # get the XML start tag
+    def xml_start_tag
+        if has_rule_name? then
+            "<" + rule_name + ">"
+        end
+    end
+    
+    # get the XML end tag
+    def xml_end_tag
+        if has_rule_name? then
+            "</" + rule_name + ">"
+        end
+    end
+    
+    # clean the tree by removing garbage nodes
+    # which are not part of the intended AST
+    def clean_tree(root_node)
+        return if(root_node.elements.nil?)
+        root_node.elements.delete_if{|node| not node.is_ast? }
+        root_node.elements.each{|e| e.clean_tree(e)}
+    end
+end
+
+
+class Treetop::Runtime::SyntaxNode
+    def as_xml
+        [(["<", getLabel, ">" ].join  if getLabel),
+        (if elements
+            elements.map { |e| e.as_xml }.join
+            else
+            text_value
+        end),
+        (["</", getLabel, ">" ].join  if getLabel)
+        ].join
+    end
+    
+    def wrap(tag,body)
+        "<#{tag}>#{body}</#{tag}>"
+    end
+    
+    def getLabel
+        nil
+    end
+    
+    
+end
+
+

data/lib/wortsammler/exe.wortsammler.rb

@@ -0,0 +1,428 @@
+require "optparse"                       # for option parser
+require 'wortsammler/log_helper'
+require 'wortsammler/class.proolib.rb'
+require 'wortsammler/class.Traceable.rb'
+require 'wortsammler/class.Traceable.md.rb'
+require 'wortsammler/version.rb'
+
+
+options = {}
+config = nil
+
+optparse = OptionParser.new do|opts|
+  # Set a banner, displayed at the top
+  # of the help screen.
+  opts.banner = ["This is Wortsammler #{Wortsammler::VERSION}",
+                 "",
+                 "Usage: Wortsammler [options]",
+                 "",
+                 "examples:",
+                 "",
+                 "   wortsammler -cbpm mymanifest.yaml",
+                 "       -- beautify collect process files from mymanifest.yaml",
+                 "",
+                 "   wortsammler -cbpi .",
+                 "       -- beautify collect process files in current folder"
+                 ].join("\n")
+
+  ##
+  # Define the options, and what they do
+
+  opts.separator nil
+  opts.separator "options:"
+  opts.separator nil
+
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on( '-h', '--help', 'display this screen' ) do
+    puts opts
+    exit
+  end
+
+
+  options[:version] = false
+  opts.on( "-v", '--version', 'print Version info, then turn on verbose mode' ) do
+    options[:version] = true
+    options[:verbose] = true
+  end
+
+  opts.separator nil
+
+  options[:init] = false
+  opts.on( "-n", '--init DIR', 'create a project folder in DIR' ) do|file|
+    options[:init] = file
+  end
+
+
+  opts.separator nil
+
+  options[:input_path] = false
+  opts.on( '-i', '--input PATH', 'set input file/project folder for processing') do|path|
+    options[:input_path] = path
+  end
+
+  options[:manifest] = false
+  opts.on( '-m', '--manifest PATH', 'set mainfest file for processing' ) do|file|
+    options[:manifest] = file
+  end
+
+  opts.separator nil
+
+  options[:outputformats] = ['pdf']
+  opts.on( '-f', '--format formatList', 'set the outputformat to formatList' ) do|formatlist|
+    options[:outputformats] = formatlist.split(":")
+  end
+
+  options[:outputfolder] = false
+  opts.on( '-o', '--output PATH', 'set the output to PATH' ) do|path|
+    options[:outputfolder] = path
+  end
+
+
+  opts.separator nil
+
+  options[:collect] = false
+  opts.on( '-c', '--collect', 'collect traceables by manifest' ) do
+    options[:collect] = true
+  end
+
+  options[:process] = false
+  opts.on( '-p', '--process', 'process documents by manifest' ) do
+    options[:process] = true
+  end
+
+
+  options[:beautify] = false
+  opts.on( "-b", '--beautify', 'bautify markdownfiles' ) do
+    options[:beautify] = true
+  end
+
+end
+
+##
+# now parse the commandline
+#
+begin
+  optparse.parse!
+rescue OptionParser::ParseError => option
+  $log.error "Invalid option #{option}"
+  exit false
+
+rescue RegexpError => error
+  $log.error "#{error}"
+  exit
+end
+
+
+module Wortsammler
+  def self.wortsammler_execute(options)
+    ##
+    #
+    # print version info
+    #
+    if options[:version] then
+      puts "Wortsammler #{Wortsammler::VERSION}"
+
+      pandoc=`pandocx -v`.split("\n")[0] rescue pandoc="error running pandoc"
+      xetex=`xelatex -v`.split("\n")[0] rescue pandoc="error running xelatex"
+
+      puts "found #{pandoc}"
+      puts "found #{xetex}"
+
+    end
+
+    ##
+    # initialize a project
+    #
+    if project_folder=options[:init] then
+      if File.exists?(project_folder)
+        $log.error "directory already exists: '#{project_folder}'"
+        exit(false)
+      end
+      Wortsammler::init_folders(project_folder)
+    end
+
+
+    ##
+    #
+    # load the manifest
+    #
+    config=nil
+    if config_file=options[:manifest] then
+      config =  ProoConfig.new(config_file)
+    end
+
+    ##
+    # process input path
+    #
+    #
+    input_files=nil
+    if input_path = options[:input_path]
+      unless File.exists? input_path then
+        $log.error "path does not exist path '#{input_path}'"
+        exit(false)
+      end
+      if File.file?(input_path)  #(RS_Mdc)
+        input_files=[input_path]
+      elsif File.exists?(input_path)
+        input_files=Dir["#{input_path}/**/*.md", "#{input_path}/**/*.markdown"]
+      end
+    end
+
+    ##
+    #
+    # beautify markdown files
+    #
+    #
+    cleaner = PandocBeautifier.new($log)
+
+    if options[:beautify]
+
+
+      # process path
+
+      if input_files then
+        input_files.each{|f| cleaner.beautify(f)}
+      end
+
+      # process manifest
+
+      if config then
+        config.input.each{|f| cleaner.beautify(f)}
+      end
+
+      unless input_files or config
+        $log.error "no input specified. Please use -m or -i to specify input"
+        exit false
+      end
+    end
+
+    ##
+    # process collect in markdown files
+    #
+
+    if options[:collect]
+
+      # collect by path
+
+      if input_files then
+        $log.warn "collect from path not yet implemented"
+      end
+
+      # collect by manifest
+
+      if config then
+        Wortsammler.collect_traces(config)
+      end
+
+      unless input_files or config
+        $log.error "no input specified. Please use -m or -i to specify input"
+        exit false
+      end
+    end
+
+
+
+    ##
+    #  process files
+    #
+    if options[:process]
+
+      if input_files then
+
+        if options[:outputformats] then
+          outputformats = options[:outputformats]
+        end
+
+        if options[:outputfolder] then
+          outputfolder = options[:outputfolder]
+        else
+          $log.error "no output folder specified"
+          exit false
+        end
+
+        unless File.exists?(outputfolder) then
+          $log.info "creating folder '#{outputfolder}'"
+          FileUtils.mkdir_p(outputfolder)
+        end
+
+        input_files.each{|f| cleaner.render_single_document(f, outputfolder, outputformats)}
+      end
+
+      # collect by manifest
+
+      if config then
+        cleaner.generateDocument(config.input,
+                                 config.outdir,
+                                 config.outname,
+                                 config.format,
+                                 config.vars,
+                                 config.editions,
+                                 config.snippets,
+                                 config)
+      end
+
+      unless input_files or config
+        $log.error "no input specified. Please use -m or -i to specify input"
+        exit false
+      end
+    end
+
+  end #execute
+
+
+  #
+  # This method can verify wortsammler options delivered by option parser
+  # @param  options [Hash] Option hash delivered by option parser
+  #
+  # @return [Boolean] true if successful. otherwise exits the program
+  def self.verify_options(options)
+    if options[:input_path] or options[:manifest] then
+      unless options[:process] or options[:beautify] or options[:collect] then
+        $log.error "no procesing option (p, b, c) specified"
+        exit false
+      end
+    end
+
+    if options[:input_path] and options[:process] then
+      unless options[:outputfolder] then
+        $log.error "no output folder specified for input path"
+        exit false
+      end
+    end
+
+    true
+  end #verify_options
+
+
+
+  #
+  # Initialize a project directory. It creates a bunch of
+  # folders, a root document, a manifest and an intial rakefile
+  #
+  # @param  root [String] [The path to the root folder of the sample project]
+  #
+  # @return [Boolean] [always true]
+  def self.init_folders(root)
+
+    folders=["ZSUPP_Manifests",
+             "ZGEN_Documents",
+             "ZSUPP_Tools",
+             "ZSUPP_Styles",
+             "ZGEN_RequirementsTracing",
+             "001_Main"
+             ]
+
+    folders.each{|folder|
+      FileUtils.mkdir_p("#{root}/#{folder}")
+    }
+
+    resourcedir=File.dirname(__FILE__)+"/../../resources"
+    Dir["#{resourcedir}/*.yaml"].each{|f|
+      FileUtils.cp(f, "#{root}/ZSUPP_Manifests")
+    }
+    FileUtils.cp("#{resourcedir}/main.md", "#{root}/001_Main")
+    FileUtils.cp("#{resourcedir}/rakefile.rb", "#{root}/ZSUPP_Tools")
+    FileUtils.cp("#{resourcedir}/default.latex", "#{root}/ZSUPP_Styles")
+    FileUtils.cp("#{resourcedir}/logo.jpg", "#{root}/ZSUPP_Styles")
+
+    true
+  end
+
+
+  #
+  # This collects the traces in a doucment specified by a manifest
+  # @param  config [ProolibConfig] the manifest model
+  #
+  # @return [type] no specific return
+  def self.collect_traces(config)
+
+    files = config.input                               # get the input files
+    rootdir = config.rootdir                           # get the root directory
+
+    downstream_tracefile = config.downstream_tracefile # String to save downstram filenames
+    reqtracefile_base = config.reqtracefile_base       # string to determine the requirements tracing results
+    upstream_tracefiles = config.upstream_tracefiles   # String to read upstream tracefiles
+
+    traceable_set = TraceableSet.new
+
+    # collect all traceables in input
+    files.each{|f|
+      x=TraceableSet.processTracesInMdFile(f)
+      traceable_set.merge(x)
+    }
+
+    # collect all upstream traceables
+    #
+    upstream_traceable_set=TraceableSet.new
+    unless upstream_tracefiles.nil?
+      upstream_tracefiles.each{|f|
+        x=TraceableSet.processTracesInMdFile(f)
+        upstream_traceable_set.merge(x)
+      }
+    end
+
+    # check undefined traces
+    all_traceable_set=TraceableSet.new
+    all_traceable_set.merge(traceable_set)
+    all_traceable_set.merge(upstream_traceable_set)
+    undefineds=all_traceable_set.undefined_ids
+    $log.warn "undefined traces: #{undefineds.join(' ')}" unless undefineds.empty?
+
+
+    # check duplicates
+    duplicates=all_traceable_set.duplicate_traces
+    if duplicates.count > 0
+      $logger.warn "duplicated trace ids found:"
+      duplicates.each{|d| d.each{|t| $log.warn "#{t.id} in #{t.info}"}}
+    end
+
+    # write traceables to the intermediate Tracing file
+    outname="#{rootdir}/#{reqtracefile_base}.md"
+
+    # poke ths sort order for the traceables
+    all_traceable_set.sort_order=config.traceSortOrder if config.traceSortOrder
+    traceable_set.sort_order=config.traceSortOrder if config.traceSortOrder
+    # generate synopsis of traceableruby 1.8.7 garbage at end of file
+
+
+    tracelist=""
+    File.open(outname, "w"){|fx|
+      fx.puts ""
+      fx.puts "\\clearpage"
+      fx.puts ""
+      fx.puts "# Requirements Tracing"
+      fx.puts ""
+      tracelist=all_traceable_set.reqtraceSynopsis(:SPECIFICATION_ITEM)
+      fx.puts tracelist
+    }
+
+    # output the graphxml
+    # write traceables to the intermediate Tracing file
+    outname="#{rootdir}/#{reqtracefile_base}.graphml"
+    File.open(outname, "w") {|fx| fx.puts all_traceable_set.to_graphml}
+
+    outname="#{rootdir}/#{reqtracefile_base}Compare.txt"
+    File.open(outname, "w") {|fx| fx.puts traceable_set.to_compareEntries}
+
+    # write the downstream_trace file - to be included in downstream - speciifcations
+    outname="#{rootdir}/#{downstream_tracefile}"
+    File.open(outname, "w") {|fx|
+      fx.puts ""
+      fx.puts "\\clearpage"
+      fx.puts ""
+      fx.puts "# Upstream Requirements"
+      fx.puts ""
+      fx.puts traceable_set.to_downstream_tracefile(:SPECIFICATION_ITEM)
+    } unless downstream_tracefile.nil?
+
+
+    # now add the upstream traces to input
+    files.concat( upstream_tracefiles) unless upstream_tracefiles.nil?
+
+    nil
+  end
+end # module
+
+Wortsammler.verify_options(options)
+Wortsammler.wortsammler_execute(options)

data/lib/wortsammler/log_helper.rb

@@ -0,0 +1,8 @@
+# setup the logger
+require 'Logger'
+$log = Logger.new(STDOUT)
+$log.level = Logger::INFO
+$log.datetime_format= "%Y-%m-%d %H:%M:%S"          
+$log.formatter = proc do |severity, datetime, progname, msg|
+  "[#{severity}] #{progname}: #{datetime.strftime($log.datetime_format)}: #{msg}\n"
+end

data/lib/wortsammler/mdTraceParser.treetop

@@ -0,0 +1,55 @@
+
+grammar TraceInMarkdown
+
+    rule top
+        (document '' )
+        {def getLabel ; "top" ; end}
+    end
+
+    rule document
+       ( (noMarkupText / trace / markupAbort)*  '')
+        {def getLabel ; "document" ; end}
+    end
+
+    rule noMarkupText
+       [^\[]+  { def as_xml; wrap('noMarkupText',super); end } 
+    end
+    
+    rule markupAbort
+       "["     
+    end
+
+	rule trace
+		traceId s? traceHead s? traceBody uptraces:traceUpLink  
+		 {def getLabel ; "trace" ; end} 
+	end
+	
+	rule traceId 
+	   "[" payload:label "]" 
+	end
+	
+	
+	rule label
+		[a-zA-Z]+ "_" [a-zA-Z]+ "_" [0-9]+ 
+	end
+	
+	rule traceHead
+		 '**' payload:(!'*' . / '\*')+ '**' 
+	end
+	
+	rule traceBody
+	   "{" payload:(nestedBody / [^{}])+ "}" 
+	end
+	
+	rule nestedBody
+	   "{" (nestedBody / [^{}])+ "}" 
+	end
+	
+	rule traceUpLink
+	    "(" payload:(","? s? label)* ")" 
+	end
+
+    rule s
+       [\s]+  
+    end
+end

data/lib/wortsammler/rake_helper.rb

@@ -0,0 +1,28 @@
+
+##
+#
+# (c) 2013 Bernhard Weichel
+#
+#
+
+
+##
+# generate a task for each manifest file
+#
+Dir["../ZSUPP_Manifests/*.yaml"].each{|file|
+  taskdesc=File.basename(file, ".yaml")
+  taskname=taskdesc.split("_")[0]
+  desc "generate #{taskdesc}"
+  task taskname do
+    cmd="wortsammler -cbpm #{file}"
+    sh cmd
+  end
+}
+
+##
+# the default task
+
+desc "print this help"
+task :default do
+  system "rake -T"
+end

data/lib/wortsammler/version.rb

@@ -0,0 +1,3 @@
+module Wortsammler
+  VERSION = "0.0.2"
+end

data/lib/wortsammler.rb

@@ -0,0 +1,5 @@
+require "wortsammler/version"
+
+module Wortsammler
+  # Your code goes here...
+end