wortsammler 1.0.3 → 2.0.1

data/lib/wortsammler.rb

@@ -33,8 +33,8 @@ module Wortsammler
     if options[:version] then
       puts "this is #{Wortsammler::PROGNAME} version #{Wortsammler::VERSION}\n"
 
-      pandoc=`pandoc -v`.split("\n")[0] rescue pandoc="error running pandoc"
-      xetex=`xelatex -v`.split("\n")[0] rescue pandoc="error running xelatex"
+      pandoc=`#{PANDOC_EXE} -v`.split("\n")[0] rescue pandoc="error running pandoc"
+      xetex=`#{LATEX_EXE} -v`.split("\n")[0] rescue pandoc="error running xelatex"
 
       $log.info "found #{pandoc}"
       $log.info "found #{xetex}"
@@ -43,7 +43,7 @@ module Wortsammler
 
       l= "-----------------"
       $log.info l
-      options.each {|k,v| $log.info "#{k}: #{v}"}
+      options.each { |k, v| $log.info "#{k}: #{v}" }
       $log.info l
     end
 
@@ -61,11 +61,11 @@ module Wortsammler
 
     ##
     #
-    # load the manifest
+    # load the manifest or use default configuration
     #
-    config=nil
+    config = ProoConfig.new();
     if config_file=options[:manifest] then
-      config =  ProoConfig.new(config_file)
+      config.load_from_file(config_file)
     end
 
     ##
@@ -78,7 +78,7 @@ module Wortsammler
         $log.error "path does not exist path '#{inputpath}'"
         exit(false)
       end
-      if File.file?(inputpath)  #(RS_Mdc)
+      if File.file?(inputpath) #(RS_Mdc)
         input_files=[inputpath]
       elsif File.exists?(inputpath)
         input_files=Dir["#{inputpath}/**/*.md", "#{inputpath}/**/*.markdown", "#{inputpath}/**/*.plantuml"]
@@ -93,17 +93,14 @@ module Wortsammler
 
     if options[:beautify]
 
-
       # process path
-
       if input_files then
-        Wortsammler.beautify(input_files)
+        Wortsammler.beautify(input_files, config)
       end
 
       # process manifest
-
-      if config then
-        Wortsammler.beautify(config.input)
+      if config.input then
+        Wortsammler.beautify(config.input, config)
       end
 
       unless input_files or config
@@ -119,27 +116,24 @@ module Wortsammler
 
     if options[:plantuml]
 
-
       # process path
-
       if input_files then
         Wortsammler.plantuml(input_files)
       end
 
       # process manifest
 
-      if config then
+      if config.input then
         Wortsammler.plantuml(config.input)
       end
 
-      unless input_files or config
+      unless input_files or config.input
         $log.error "no input specified. Please use -m or -i to specify input"
         exit false
       end
     end
 
 
-
     ##
     # process collect in markdown files
     #
@@ -154,18 +148,17 @@ module Wortsammler
 
       # collect by manifest
 
-      if config then
+      if config.input then
         Wortsammler.collect_traces(config)
       end
 
-      unless input_files or config
+      unless input_files or config.input
         $log.error "no input specified. Please use -m or -i to specify input"
         exit false
       end
     end
 
 
-
     ##
     #  process files
     #
@@ -189,12 +182,12 @@ module Wortsammler
           FileUtils.mkdir_p(outputfolder)
         end
 
-        input_files.each{|f| Wortsammler.render_single_document(f, outputfolder, outputformats)}
+        input_files.each { |f| Wortsammler.render_single_document(f, outputfolder, outputformats, config) }
       end
 
       # collect by manifest
 
-      if config then
+      if config.input then
         Wortsammler.process(config)
       end
 
@@ -205,19 +198,23 @@ module Wortsammler
     end
 
     nil
-  end #execute
+  end
+
+  #execute
 
 
   #
   # beautify a list of Documents
   # @param  paths [Array of String] Array of filenames which shall be cleaned.
+  # @param [ProoConfig] config
   #
   # @return [Nil] no return
-  def self.beautify(paths)
+  def self.beautify(paths, config=nil)
 
     cleaner = PandocBeautifier.new($log)
+    cleaner.config = config if config
 
-    paths.each{|f| cleaner.beautify(f)}
+    paths.each { |f| cleaner.beautify(f) }
     nil
   end
 
@@ -225,16 +222,16 @@ module Wortsammler
   #
   # plantuml a list of Documents
   # @param  paths [Array of String] Array of filenames which shall be converted.
+  # @param [ProoConfig] config
   #
   # @return [Nil] no return
   def self.plantuml(paths)
 
-    cleaner = PandocBeautifier.new($log)
     plantumljar=File.dirname(__FILE__)+"/../resources/plantuml.jar"
 
-    paths.each{|f|
-      cmd = "java -jar \"#{plantumljar}\" -v \"#{f}\" 2>&1"
-      r=`#{cmd}`
+    paths.each { |f|
+      cmd          = "java -jar \"#{plantumljar}\" -v \"#{f}\" 2>&1"
+      r            =`#{cmd}`
       no_of_images = r.split($/).grep(/Number of image/).first.split(":")[1]
 
       $log.info("#{no_of_images} uml diagram(s) in #{File.basename(f)}")
@@ -245,13 +242,14 @@ module Wortsammler
 
 
   #
-  # process the documents according to the maanifest
+  # process the documents according to the manifest
   #
   # @param  config [ProoConfig] A configuration object representing the manifest.
   #
   # @return [Nil] no return
   def self.process(config)
     cleaner = PandocBeautifier.new($log)
+    cleaner.config = config
 
     cleaner.generateDocument(config.input,
                              config.outdir,
@@ -272,13 +270,15 @@ module Wortsammler
   # render a single document
   # @param  filename [String] The filename of the document file which shall be rendered
   # @param  outputfolder [String] The path to the outputfolder where the output files shall be placed.
+  # @param [ProoConfig] config
   #
   #
   # @param  outputformats [Array of String] The list of formats which shall be produced
   #
   # @return [Nil] no return
-  def self.render_single_document(filename, outputfolder, outputformats)
+  def self.render_single_document(filename, outputfolder, outputformats, config=nil)
     cleaner = PandocBeautifier.new($log)
+    cleaner.config = config if config
     cleaner.render_single_document(filename, outputfolder, outputformats)
     nil
   end
@@ -299,14 +299,14 @@ module Wortsammler
              "ZGEN_RequirementsTracing",
              "001_Main",
              "900_snippets"
-             ]
+    ]
 
-    folders.each{|folder|
+    folders.each { |folder|
       FileUtils.mkdir_p("#{root}/#{folder}")
     }
 
     resourcedir=File.dirname(__FILE__)+"/../resources"
-    Dir["#{resourcedir}/*.yaml"].each{|f|
+    Dir["#{resourcedir}/*.yaml"].each { |f|
       FileUtils.cp(f, "#{root}/ZSUPP_Manifests")
     }
     FileUtils.cp("#{resourcedir}/main.md", "#{root}/001_Main")
@@ -326,17 +326,17 @@ module Wortsammler
   # @return [Nil] no  return
   def self.collect_traces(config)
 
-    files = config.input                               # get the input files
-    rootdir = config.rootdir                           # get the root directory
+    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
+    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|
+    files.each { |f|
       x=TraceableSet.processTracesInMdFile(f)
       traceable_set.merge(x)
     }
@@ -345,7 +345,7 @@ module Wortsammler
     #
     upstream_traceable_set=TraceableSet.new
     unless upstream_tracefiles.nil?
-      upstream_tracefiles.each{|f|
+      upstream_tracefiles.each { |f|
         x=TraceableSet.processTracesInMdFile(f)
         upstream_traceable_set.merge(x)
       }
@@ -363,20 +363,20 @@ module Wortsammler
     duplicates=all_traceable_set.duplicate_traces
     if duplicates.count > 0
       $log.warn "duplicated trace ids found:"
-      duplicates.each{|d| d.each{|t| $log.warn "#{t.id} in #{t.info}"}}
+      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"
+    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
+    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|
+    tracelist                   =""
+    File.open(outname, "w") { |fx|
       fx.puts ""
       fx.puts "\\clearpage"
       fx.puts ""
@@ -389,14 +389,14 @@ module Wortsammler
     # 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}
+    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}
+    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|
+    File.open(outname, "w") { |fx|
       fx.puts ""
       fx.puts "\\clearpage"
       fx.puts ""
@@ -407,7 +407,7 @@ module Wortsammler
 
 
     # now add the upstream traces to input
-    files.concat( upstream_tracefiles) unless upstream_tracefiles.nil?
+    files.concat(upstream_tracefiles) unless upstream_tracefiles.nil?
 
     nil
   end
@@ -419,6 +419,14 @@ module Wortsammler
   #
   # @return [Boolean] true if successful. otherwise exits the program
   def self.verify_options(options)
+
+    if options[:process] or options[:beautify] or options[:coollect] then
+      unless options[:inputpath] or options[:manifest] then
+        $log.error "no input specified"
+        exit false
+      end
+    end
+
     if options[:inputpath] or options[:manifest] then
       unless options[:process] or options[:beautify] or options[:collect] or options[:plantuml] then
         $log.error "no procesing option (p, b, c, u) specified"
@@ -428,10 +436,10 @@ module Wortsammler
 
     unless options[:outputfolder] then
       outputfolder="."
-      inputpath=options[:inputpath]
+      inputpath   =options[:inputpath]
       unless inputpath.nil? then
-        outputfolder = inputpath                    if File.directory?(inputpath)
-        outputfolder = File.dirname(inputpath)    if File.file?(inputpath)
+        outputfolder = inputpath if File.directory?(inputpath)
+        outputfolder = File.dirname(inputpath) if File.file?(inputpath)
       end
       options[:outputfolder] = outputfolder
     end
@@ -447,5 +455,4 @@ module Wortsammler
   end #verify_options
 
 
-
 end # module

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

@@ -13,6 +13,10 @@ Treetop.load File.dirname(__FILE__) + "/mdTraceParser.treetop"
 class TraceableSet
 
 
+  def mk_hyperlink(id)
+    idm = id.gsub("_","-")
+    "[\[#{id}\]](#RT-#{idm})"
+  end
 
   # this generates a synopsis of traces in markdown Format
   # @param [Symbol] selectedCategory the the category of the Traceables
@@ -23,20 +27,18 @@ class TraceableSet
     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>"}
+      lContributes = t.contributes_to.
+          map { |c| mk_hyperlink(c) }
 
       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}"
+        "    - #{mk_hyperlink(u.id)} #{u.header_orig}"
       }
 
-      ["- ->[#{t.id}] <!-- --> <a id=\"RT-#{tidm}\"/>**#{t.header_orig}**" +
+      ["- #{mk_hyperlink(t.id)} <!-- --> <a id=\"RT-#{tidm}\"/>**#{t.header_orig}**" +
        #                     "  (#{t.contributes_to.join(', ')})", "",
        "  (#{lContributes.join(', ')})", "",
        luptraces
@@ -50,7 +52,7 @@ class TraceableSet
     all_traces(selectedCategory).
       sort_by{|x| trace_order_index(x.id) }.
     map{|t|
-      "\n\n[#{t.id}] **#{t.header_orig}** { }()"
+      "\n\n\\[#{t.id}\\] **#{t.header_orig}** { }()"
     }.join("\n\n")
   end
 

data/lib/wortsammler/class.Traceable.rb

@@ -23,16 +23,16 @@ class TraceableSet
   # @return [type] [description]
   def initialize()
     # the traces
-    @traces={}
+    @traces = {}
 
     # the list of supporters
     # supporters for foo 0 @@supported_by["foo"]
-    @supported_by={}
+    @supported_by = {}
 
 
     # define the sort order policy
     # it is the same for all slots
-    @sortOrder=[]
+    @sortOrder = []
 
   end
 
@@ -63,7 +63,7 @@ class TraceableSet
   # @param  category  [Symbol] Restrict the comparison to a particlar category
   #
   # @return [Array] the ids of the added traces (list of trace_id which are not in @referece_set)
-  def added_trace_ids(reference_set, category=nil)
+  def added_trace_ids(reference_set, category = nil)
     self.all_trace_ids(category) - reference_set.all_trace_ids(category)
   end
 
@@ -74,9 +74,9 @@ class TraceableSet
   # @param  category [Symbol] Restrict the operation to traceables of this category.
   #
   # @return [Array] List of trace_id which changed not in reference_set
-  def changed_trace_ids(reference_set, category=nil)
-    candidates=self.all_trace_ids(category) & reference_set.all_trace_ids(category)
-    candidates.map{|candidate|
+  def changed_trace_ids(reference_set, category = nil)
+    candidates = self.all_trace_ids(category) & reference_set.all_trace_ids(category)
+    candidates.map { |candidate|
       self[candidate].get_diff(reference_set[candidate])
     }.compact
   end
@@ -87,9 +87,9 @@ class TraceableSet
   # @param  category [Symbol] Restrict the operation to traceables of this category.
   #
   # @return [Array] List of trace_id which unchanged
-  def unchanged_trace_ids(reference_set, category=nil)
-    candidates=self.all_trace_ids(category) & reference_set.all_trace_ids(category)
-    candidates.select{|candidate|
+  def unchanged_trace_ids(reference_set, category = nil)
+    candidates = self.all_trace_ids(category) & reference_set.all_trace_ids(category)
+    candidates.select { |candidate|
       self[candidate].get_diff(reference_set[candidate]).nil?
     }.compact
   end
@@ -101,7 +101,7 @@ class TraceableSet
   # @param  category [Symbol] Restrict the operation to traceables of this category.
   #
   # @return [Array] List of trace_id which are deleted (not in current set)
-  def deleted_trace_ids(reference_set, category=nil)
+  def deleted_trace_ids(reference_set, category = nil)
     reference_set.all_trace_ids(category) - self.all_trace_ids(category)
   end
 
@@ -109,31 +109,31 @@ class TraceableSet
   # export the trace as graphml for yed
   # @return - the requirements tree in graphml
   def to_graphml
-    f = File.open("#{File.dirname(__FILE__)}/../../resources/requirementsSynopsis.graphml")
+    f   = File.open("#{File.dirname(__FILE__)}/../../resources/requirementsSynopsis.graphml")
     doc = Nokogiri::XML(f)
     f.close
 
-    graph=doc.xpath("//xmlns:graph").first
+    graph = doc.xpath("//xmlns:graph").first
 
     # generate all nodes
-    self.all_traces(nil).each{|theTrace|
-      n_node = Nokogiri::XML::Node.new "node", doc
-      n_node["id"] = theTrace.id
-      n_data = Nokogiri::XML::Node.new "data", doc
-      n_data["key"]= "d6"
-      n_ShapeNode = Nokogiri::XML::Node.new "y:ShapeNode", doc
-      n_NodeLabel = Nokogiri::XML::Node.new "y:NodeLabel", doc
+    self.all_traces(nil).each { |theTrace|
+      n_node              = Nokogiri::XML::Node.new "node", doc
+      n_node["id"]        = theTrace.id
+      n_data              = Nokogiri::XML::Node.new "data", doc
+      n_data["key"]       = "d6"
+      n_ShapeNode         = Nokogiri::XML::Node.new "y:ShapeNode", doc
+      n_NodeLabel         = Nokogiri::XML::Node.new "y:NodeLabel", doc
       n_NodeLabel.content = "[#{theTrace.id}] #{theTrace.header_orig}"
       n_ShapeNode << n_NodeLabel
       n_data << n_ShapeNode
       n_node << n_data
       graph << n_node
 
-      theTrace.contributes_to.each{|up|
-        n_edge=Nokogiri::XML::Node.new "edge", doc
-        n_edge["source" ] = theTrace.id
-        n_edge["target" ] = up
-        n_edge["id"     ] = "#{up}_#{theTrace.id}"
+      theTrace.contributes_to.each { |up|
+        n_edge           = Nokogiri::XML::Node.new "edge", doc
+        n_edge["source"] = theTrace.id
+        n_edge["target"] = up
+        n_edge["id"]     = "#{up}_#{theTrace.id}"
         graph << n_edge
       }
     }
@@ -146,7 +146,7 @@ class TraceableSet
   # @return [Array of String] an array of the registered Traceables
   #                              of the selectedCategory
   def all_trace_ids(selected_category = nil)
-    @traces.keys.select{|x|
+    @traces.keys.select { |x|
       y = @traces[x].first
       selected_category.nil? or y.category == selected_category
     }.sort
@@ -161,7 +161,7 @@ class TraceableSet
   #
   # @return [Array of Traceable] The array of traceables
   def all_traces(selected_category = nil)
-    all_trace_ids(selected_category).map{|t| @traces[t].first}
+    all_trace_ids(selected_category).map { |t| @traces[t].first }
   end
 
 
@@ -187,43 +187,43 @@ class TraceableSet
   # this lists duplicate traces
   # @return [Array of String] the list of the id of duplicate Traces
   def duplicate_ids()
-    @traces.select{|id, traceables| traceables.length > 1}.map{|id, traceable| id}.sort
+    @traces.select { |id, traceables| traceables.length > 1 }.map { |id, traceable| id }.sort
   end
 
   # this lists duplicate traces
   # @return [Array of Traceable] the list duplicate Traces.
   def duplicate_traces()
-    @traces.select{|id, traceables| traceables.length > 1}.map{|id, traceable| traceable}.sort
+    @traces.select { |id, traceables| traceables.length > 1 }.map { |id, traceable| traceable }.sort
   end
 
 
   # this serializes a particular slot for caching
   # @param file [String] name of the cachefile
   def dump_to_marshal(file)
-    File.open(file, "wb"){|f|
+    File.open(file, "wb") { |f|
       Marshal.dump(self, f)
     }
   end
 
   # this loads cached information into a particular slot
   # @param file [String] name of the cachefile
-  def  self.load_from_marshal(file)
-    a=nil
-    File.open(file, "rb"){|f| a=Marshal.load(f)}
+  def self.load_from_marshal(file)
+    a = nil
+    File.open(file, "rb") { |f| a = Marshal.load(f) }
     a
   end
 
   # this merges a TraceableSet
   # @return [Treaceable] the current traceable set
   def merge(set)
-    set.all_traces_as_arrays.values.flatten.each{|t| self.add(t)}
+    set.all_traces_as_arrays.values.flatten.each { |t| self.add(t) }
   end
 
   # this retunrs traces marked as supported but not being defined
   # @return [Array of String] the list of the id of undefined Traces
   #         traces which are marked as uptraces but do not exist.
   def undefined_ids
-    @supported_by.keys.select{|t| not @traces.has_key?(t)}.sort
+    @supported_by.keys.select { |t| not @traces.has_key?(t) }.sort
   end
 
   #
@@ -243,7 +243,7 @@ class TraceableSet
   # it is placed according to the sequence
   # in the array. Otherwise it is sorted at the end
   def sort_order= (sort_order)
-    @sort_order=sort_order
+    @sort_order = sort_order
   end
 
   # this determines the sort order index of a trace
@@ -252,11 +252,11 @@ class TraceableSet
   #                 the sort order index shall be coumputed.
   # @return [String] the sort key of the given id.
   def trace_order_index(trace_id)
-    global=@sort_order.index{|x| trace_id.start_with? x} ||
-      (@sort_order.length+1)
+    global = @sort_order.index { |x| trace_id.start_with? x } ||
+        (@sort_order.length + 1)
 
     # add the {index} of the trace to
-    orderId = [global.to_s.rjust(5,"0"),trace_id].join("_")
+    orderId = [global.to_s.rjust(5, "0"), trace_id].join("_")
     orderId
   end
 
@@ -272,11 +272,10 @@ class TraceableSet
   #
   # @return [type] [description]
   def to_compareEntries
-    all_traces.sort.map{|t| "\n\n[#{t.id}]\n#{t.as_oneline}" }.join("\n")
+    all_traces.sort.map { |t| "\n\n[#{t.id}]\n#{t.as_oneline}" }.join("\n")
   end
 
 
-
   #############################
 
   private
@@ -286,7 +285,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="*"/>
@@ -307,16 +306,19 @@ class TraceableSet
 end
 
 
+class Traceable
 
+  def clear_trace_id(id)
+    id.gsub("\\_", "_")
+  end
 
-class Traceable
   include Comparable
 
 
   # String: The trace-Id
-  attr_accessor :id
+  attr_reader :id
   # string: the alternative Id, used e.g. for the constraint number
-  attr_accessor :alternative_id
+  attr_reader :alternative_id
   # String: The header in plain text
   attr_accessor :header_plain
   # String: The header in original format
@@ -326,7 +328,7 @@ class Traceable
   # String: he body in original format
   attr_accessor :body_orig
   # Array of Strings: The uplink as an array of Trace-ids
-  attr_accessor :contributes_to
+  attr_reader :contributes_to
   # String: the Traceable in its original format
   attr_accessor :trace_orig
   # String: origin of the entry
@@ -338,18 +340,30 @@ class Traceable
 
 
   def initialize()
-    @id = ""
+    @id             = ""
     @alternative_id = ""
-    @header_orig = ""
-    @body_plain = ""
-    @body_orig = ""
+    @header_orig    = ""
+    @body_plain     = ""
+    @body_orig      = ""
     @contributes_to = []
-    @trace_orig = ""
-    @category = ""
-    @info = ""
+    @trace_orig     = ""
+    @category       = ""
+    @info           = ""
+  end
+
+  def id=(id)
+    @id = clear_trace_id(id)
+  end
+
+  def alternative_id=()
+    @alternative_id = clear_trace_id(id)
+  end
+
+  def contributes_to=(list)
+    @contributes_to = list.map { |id| id = clear_trace_id(id) }
   end
 
-  # define the comparison to makeit really comaprable
+  # define the comparison to makeit really comparable
   # @param [Traceable] other the other traceable for comparison.
   def <=> (other)
     @id <=> other.id
@@ -366,19 +380,19 @@ class Traceable
     if newval == oldval
       result = nil
     else
-      diff_as_html= "<pre>#{other.trace_orig}</pre><hr/><pre>#{self.trace_orig}</pre>"#Diffy::Diff.new(other.trace_orig, self.trace_orig).to_s(:text)
-      rawDiff = Diffy::Diff.new(self.trace_orig, other.trace_orig)
-      diff_as_html=rawDiff.to_s(:html)
+      diff_as_html = "<pre>#{other.trace_orig}</pre><hr/><pre>#{self.trace_orig}</pre>" #Diffy::Diff.new(other.trace_orig, self.trace_orig).to_s(:text)
+      rawDiff      = Diffy::Diff.new(self.trace_orig, other.trace_orig)
+      diff_as_html = rawDiff.to_s(:html)
 
-      result = [self.id, similarity, diff_as_html]
-      diff_as_html=nil
+      result       = [self.id, similarity, diff_as_html]
+      diff_as_html = nil
     end
     result
   end
 
 
   def get_comparison_string
-    "#{header_orig};#{body_orig};#{contributes_to.sort}".gsub(/\s+/," ")
+    "#{header_orig};#{body_orig};#{contributes_to.sort}".gsub(/\s+/, " ")
   end
 
   def as_oneline