twb 4.9.4 → 5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bf5871fe93aaf4afc19f4c4b789d18db29545c43f77c6ae1d2c901dc23cd142
-  data.tar.gz: e529613db65063341cde12d6393201765f3a53b680e4fbc7fe21707b9ff83681
+  metadata.gz: 786d3cb3bde8d6d6db0ee5c4063e998df008b5ca1354ba8fb4fc77c06aa7e10d
+  data.tar.gz: f9e73b1494d4d3946749f03e045caf6db221d4750ac12d99a5af037a77ca955a
 SHA512:
-  metadata.gz: 7fb310fd663173d925df07488ec1f8d147651ca6588b725f03acaa99e88cfbcc07bb5aed2b797a8e70afd57143466a06ca0857bab0e4bdad99fda42423093652
-  data.tar.gz: 460b6aee7fe9bf62baa9611a350dc3b7fe671ae18c03b8943431506a43bf0598247e92e784604cf35450bdc1f3dc09c04380ae43ff35c33344877885f16ca191
+  metadata.gz: 1ed3f0c9dfd61b8accd948ac10f29382f16c0fc8b15c415c8f5de55ab5a2739b6e7991e82c02ec953fd1507cb27079b59a5a15785da4a44b2fbe57f5e08eb083
+  data.tar.gz: 6171c5e6615b4d426690fca14bc92fea5e7325ee143985bd2fd4fd178833c41085a9e0b9f75a219884fdc900ab4d04a56ccd12d69580636e85b30855dd5f7792

data/lib/tfl/Flow.rb

@@ -0,0 +1,311 @@
+
+#  Copyright (C) 2014, 2020  Chris Gerrard
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'nokogiri'
+require 'zip'
+
+module Flow
+
+
+  ##
+  # A Tableau Prep Flow file.
+  #
+  class Flow < TabClass
+
+    attr_reader :name,         :dir,    :type,      :modtime
+    attr_reader :version,      :build,  :platform,  :base
+    attr_reader :root
+    #--
+    attr_reader :datasources,     :datasource 
+    attr_reader :datasourceNames, :datasourceUINames, :dataSourceNamesMap
+    # attr_reader :orphanDataSources  # i.e. not referenced in any Worksheet
+    #--
+    # attr_reader :dashboards,      :storyboards,       :worksheets
+    # attr_reader :parameters,      :actions
+    # attr_reader :valid
+
+    ##
+    # Creates a Flow from its file name.
+    #
+    # == Parameters:
+    # flowWithDir
+    #   The Flow's file name, the Flow can be a TWB or TWBX file.
+    #
+    def initialize tflWithDir
+      raise ArgumentError.new("ERROR in Flow creation: '#{tflWithDir}' must be a String, is a #{tflWithDir.class} \n ")    unless tflWithDir.is_a? String
+      raise ArgumentError.new("ERROR in Flow creation: '#{tflWithDir}' must have an extension of .tfl or .tflx \n ")       unless tflWithDir.upcase.end_with?(".TFL", ".TFLX")
+      raise ArgumentError.new("ERROR in Flow creation: '#{tflWithDir}' must must be a file, is a Directory\\Folder \n ")   if File.directory?(tflWithDir)
+      raise ArgumentError.new("ERROR in Flow creation: '#{tflWithDir}' cannot be found, must be a Tableau Flow file. \n ") unless File.file?(tflWithDir)
+      @valid = false
+      if File.file?(tflWithDir) then
+        @name    = File.basename(tflWithDir)
+        @dir     = File.dirname(File.expand_path(tflWithDir))
+        @modtime = File.new(tflWithDir).mtime.strftime("%Y-%m-%d %H:%M:%S")
+        case File.extname(tflWithDir).downcase
+          when '.tlf'  then processTFL(tflWithDir)
+          when '.tflx' then processTFLX(flowWithDir)
+        end
+      end
+    end
+
+    def id
+        @id ||= @id = @name.hash
+    end
+
+    def build
+      @build ||= loadBuild
+    end
+
+    def release
+      @build ||= loadBuild
+    end
+
+    def worksheets
+      @worksheets.values
+    end
+
+    def worksheet name
+      @worksheets[name]
+    end
+
+    def worksheetNames
+      @worksheets.keys
+    end
+
+    def dashboards
+      @dashboards.values
+    end
+
+    def dashboardNames
+      @dashboards.keys
+    end
+
+    def dashboard name
+      @dashboards[name]
+    end
+
+    def actions
+      @actions.values
+    end
+
+    def actionNames
+      @actions.keys
+    end
+
+    def datasource name
+      @dataSourceNamesMap[name]
+    end
+
+    def parameters
+      @parameters ||= loadParameters
+    end
+
+    def orphanDataSources
+      @orphanDataSources ||= identifyOrphandatasoUrceS
+    end
+
+    def storyboards
+      @storyboards.values
+    end
+
+    def storyboardNames
+      @storyboards.keys
+    end
+
+    def storyboard name
+      @storyboards[name]
+    end
+
+    private
+
+    def processTFLX(twbxWithDir)
+      Zip::File.open(twbxWithDir) do |zip_file|
+        twb   = zip_file.glob('*.twb').first
+        @ndoc = Nokogiri::XML(twb.get_input_stream)
+        @type = :twbx
+        processDoc
+      end
+    end
+
+    def processTFL(twbFile)
+      @ndoc = Nokogiri::XML(open(twbFile))
+      @type = :twb
+      processDoc
+    end
+
+    def processDoc
+      @valid = true
+    end
+
+    def loadBuild
+      # - earlier Version, need to confirm when source-build began 
+      #   @build   = @ndoc.xpath('/flow/comment()').text.gsub(/^[^0-9]+/,'').strip
+      @build = if !@ndoc.at_xpath('/flow/@source-build').nil?
+                   @ndoc.at_xpath('/flow/@source-build').text
+               else 
+                   if @ndoc.at_xpath('/flow/comment()').nil?
+                      'not found'
+                   else
+                      @ndoc.at_xpath('/flow/comment()').text.gsub(/^[^0-9]+/,'').strip
+                  end
+               end
+    end
+
+    def loaddatasources
+      # puts "LOAD DATA SOURCES"
+      # @dataSourcesNode = @ndoc.at_xpath('//flow/datasources')
+      @datasources        = Set.new
+      @datasourceNames    = SortedSet.new
+      @datasourceUINames  = SortedSet.new
+      @dataSourceNamesMap = {}
+      datasourceNodes     = @ndoc.xpath('//flow/datasources/datasource')
+      # puts "DATASOURCENODES : #{@datasourceNodes.length}"
+      datasourceNodes.each do |node|
+        datasource = Twb::DataSource.new(node,self)
+        @datasources << datasource
+        @datasourceNames    << datasource.name
+        @datasourceNames    << datasource.uiname
+        @datasourceUINames  << datasource.uiname
+        @dataSourceNamesMap[datasource.name]   = datasource 
+        @dataSourceNamesMap[datasource.uiname] = datasource 
+      end
+      # puts "DATASOURCES    : #{@datasources.length}"
+    end
+
+    def loadWorksheets
+      @worksheets  = {}
+      hiddenSheets = []
+      @ndoc.xpath('//flow/windows/window[@hidden="true"]').each do |hs|
+        hiddenSheets << hs['name']
+      end
+      sheets = @ndoc.xpath('//flow/worksheets/worksheet' ).to_a
+      sheets.each do |node|
+        sheet = Twb::Worksheet.new(node, self)
+        sheet.hidden = hiddenSheets.include? sheet.name 
+        @worksheets[sheet.name] = sheet
+      end
+    end
+
+    def loadDashboards
+      @dashesNode = @ndoc.at_xpath('//flow/dashboards')
+      @dashboards = {}
+      dashes = @ndoc.xpath('//flow/dashboards/dashboard').to_a
+      dashes.each do |node|
+        unless node.attr('type') == 'storyboard' then
+          dashboard = Twb::Dashboard.new(node, @worksheets)
+          @dashboards[dashboard.name] = dashboard
+        end
+      end
+    end
+
+    def loadStoryboards
+      @storyboards = {}
+      boards = @ndoc.xpath("//flow/dashboards/dashboard[@type='storyboard']" ).to_a
+      boards.each do |node|
+        sheet = Twb::Storyboard.new(node)
+        @storyboards[sheet.name] = sheet
+      end
+    end
+
+    def loadWindows
+      @windowsnode = @ndoc.at_xpath("//flow/windows")
+      @windows = {}
+      windows  = @ndoc.xpath("//flow/windows/window[@name]")
+      windows.each do |node|
+        window = Twb::Window.new(node)
+        @windows[window.name] = window
+      end
+    end
+
+    def loadActions
+      @actions = {}
+      actionNodes = @ndoc.xpath("//flow/actions/action")
+      actionNodes.each do |anode|
+        action = Twb::Action.new(anode, @flownode)
+        @actions[action.uiname] = action
+      end
+    end
+
+    def identifyOrphandatasoUrceS
+      sheetDataSources = Set.new
+      @worksheets.values.each do |sheet|
+        sheet.datasources.each do |ds|
+            sheetDataSources << ds.uiname
+        end
+      end
+      @orphanDataSources = @datasourceUINames - sheetDataSources
+    end
+
+    def writeTwb(name=@name)
+      $f = File.open(name,'w')
+      if $f
+          $f.puts @ndoc
+          $f.close
+      end
+      return name
+    end
+
+    def writeTwbx(name=@name)
+        emit  "Writing the Workbook, need implementation"
+    end
+
+    # Make sure that the TWB has a <dashboards> node.
+    # It's possible for a TWB to have no dashboards, and therefore no <dashboards> node.
+    def ensureDashboardsNodeExists
+      if @dashesNode.nil?
+        @dashesNode = Nokogiri::XML::Node.new "dashboards", @ndoc
+        # TODO fix this @dataSourcesNode.add_next_sibling(@dashesNode)
+      end
+    end
+
+    def ensureWindowsNodeExists
+      if @windowsnode.nil?
+        @windowsnode = Nokogiri::XML::Node.new "windows", @ndoc
+        # TODO fix this @dataSourcesNode.add_next_sibling(@windowsnode)
+      end
+    end
+
+    def getNewDashboardTitle(t)
+      title = t
+      if @datasources.include?(title)
+        inc = 0
+        loop do
+          inc+=1
+          title = t + ' ' + inc.to_s
+          if !@datasources.include?(title)
+            break
+          end
+        end
+      end
+      return title
+    end
+
+    def loadParameters
+      @parameters = {}
+      paramsDS = ndoc.at_xpath('./flow/datasources/datasource[@name="Parameters"]')
+      unless paramsDS.nil?
+        paramNodes = paramsDS.xpath('.//column')
+        paramNodes.each do |pn|
+          parameter = Twb::Parameter.new pn
+          @parameters[parameter.name] = parameter
+        end
+      end
+      return @parameters
+    end
+
+  end  # class Flow
+
+end  # module Twb

data/lib/twb.rb

@@ -54,6 +54,7 @@ require_relative 'twb/analysis/documentedfieldsmarkdownemitter'
 require_relative 'twb/analysis/annotatedfieldscsvemitter'
 require_relative 'twb/analysis/workbooksummaryanalyzer'
 require_relative 'twb/analysis/calculatedfields/calculatedfieldsanalyzer'
+require_relative 'twb/analysis/calculatedfields/dotanalyzer'
 require_relative 'twb/analysis/calculatedfields/groupfieldsanalyzer'
 require_relative 'twb/analysis/calculatedfields/markdownemitter'
 require_relative 'twb/analysis/calculatedfields/csvemitter'
@@ -73,12 +74,12 @@ require_relative 'twb/analysis/sheets/worksheetsummarizer'
 require_relative 'twb/analysis/sheets/worksheetdatastructurecsvemitter'
 require_relative 'twb/analysis/sheets/sheetfiltersanalyzer'
 require_relative 'twb/analysis/sheets/sheetfieldsanalyzer'
+require_relative 'twb/analysis/sheets/dashboardsummarizer'
 require_relative 'twb/analysis/sheets/dashsheetsanalyzer'
 require_relative 'twb/analysis/sheets/sheetsintooltipanalyzer'
 
-
 # Represents Tableau Workbooks, their contents, and classes that analyze and manipulate them.
 #
 module Twb
-  VERSION = '4.9.4'
+  VERSION = '5.2.1'
 end

data/lib/twb/analysis/calculatedfields/calculatedfieldsanalyzer.rb

@@ -78,12 +78,12 @@ module Analysis
       @fieldTables = {}
 
 
-      @@dotHeader = <<DOTHEADER
-  digraph g {
-      graph [rankdir="LR" splines=line];
-      node  [shape="box"  width="2"];
+#       @@dotHeader = <<DOTHEADER
+#   digraph g {
+#       graph [rankdir="LR" splines=line];
+#       node  [shape="box"  width="2"];
 
-DOTHEADER
+# DOTHEADER
 
       def initialize(**args)
           emit "initialize CalculatedFieldsAnalyzer args #{args}"
@@ -141,7 +141,7 @@ DOTHEADER
           # end
           processDataSource ds
         end
-        mapTwb
+        # mapTwb
         emitGml
         @twbCount += 1
         finis
@@ -195,10 +195,10 @@ DOTHEADER
               calculatedFields.add calcField.id
               dsFields[calcField.uiname] = calcField
               # if @doGraph
-                calcFieldNode    = Twb::Util::Graphnode.new(name: calcField.uiname, id: calcField.id, type: calcField, properties: {:DataSource => ds.uiname})
-                @nodes.add calcFieldNode
-                dsFieldEdge     = Twb::Util::Graphedge.new(from: dataSourceNode, to: calcFieldNode, relationship: 'contains')
-                @edges.add dsFieldEdge
+              calcFieldNode    = Twb::Util::Graphnode.new(name: calcField.uiname, id: calcField.id, type: calcField, properties: {:DataSource => ds.uiname})
+              @nodes.add calcFieldNode
+              dsFieldEdge     = Twb::Util::Graphedge.new(from: dataSourceNode, to: calcFieldNode, relationship: 'contains')
+              @edges.add dsFieldEdge
               # end
               calculation     = calcField.calculation
               if calculation.has_formula
@@ -249,47 +249,26 @@ DOTHEADER
                                          ]
                   end
                   #-- collect fields referenced in formula
-                  emit "# Calculated Fields: #{calculation.calcFields.length}"
-                  calculation.calcFields.each do |rf|
-                    emit "  referenced field       ::'#{rf}'"
-                    emit "  referenced field.name  ::'#{rf.name.nil?}'  :: '#{rf.name}'"
-                    emit "  referenced field.uiname::'#{rf.uiname}'"
-                    # if @doGraph
-                    unless rf.uiname.nil?
-                      properties = {'DataSource' => ds.uiname, 'DataSourceReference' => 'local', :source => rf}
-                      refFieldNode  = Twb::Util::Graphnode.new(name: rf.uiname, id: rf.id,   type: rf.type, properties: properties)
-                      @nodes.add refFieldNode
-                      fieldFieldEdge = Twb::Util::Graphedge.new(from: calcFieldNode,  to: refFieldNode, relationship: 'references')
-                      @edges.add fieldFieldEdge
-                    end
-                    # end
-                    referencedFields.add rf.id
-                    refFieldTable = ds.fieldTable(rf.name)
-                    emit "refFieldTable.nil? : #{refFieldTable.nil?}"
-                    unless refFieldTable.nil?
-                      tableID        = refFieldTable + ':::' + ds.uiname
-                      tableName      = "||#{refFieldTable}||"
-                      # if @doGraph
-                        tableNode      = Twb::Util::Graphnode.new(name: tableName,      id: tableID,   type: :DBTable, properties: properties)
-                        @nodes.add tableNode
-                        fieldFieldEdge = Twb::Util::Graphedge.new(from: refFieldNode,  to: tableNode, relationship: 'is a field in')
-                        @edges.add fieldFieldEdge
-                      # end
-                      # fldToDsNode    = tableNode
-                    end
+                  emit "# Calculated Fields: #{calculation.referencedFields.length}"
+                  calculation.referencedFields.each do |rf|
+                    emit "  referenced field       :: %12s  %s " % [ rf.dataSourceName, rf.uiname ]
                     @csvFormulaFields <<  [ 
                                             @referencedFieldsCount += 1,
                                             @twb.name,
                                             # @modTime,
-                                            ds.uiname,
+                                            rf.dataSourceName, # ds.uiname,
                                             calcField.uiname,
                                             calculation.formulaFlat,
                                             calculation.formulaFlatResolved,
                                             rf.name,
-                                            rf.uiname,
-                                            rf.id,
-                                            refFieldTable
+                                            rf.uiname,   #.uiname,
+                                            '',  # rf.id,
+                                            '',  #refFieldTable
                                           ]
+                    refFieldNode    = Twb::Util::Graphnode.new(name: rf.uiname, id: rf.id, type: rf, properties: {:DataSource => ds.uiname})
+                    @nodes.add refFieldNode
+                    refFieldEdge     = Twb::Util::Graphedge.new(from: calcFieldNode, to: refFieldNode , relationship: 'references')
+                    @edges.add refFieldEdge
                   end # resolvedFields.each do
               end # if calculation.has_formula
             end # ds.calculatedFields.each 
@@ -298,8 +277,8 @@ DOTHEADER
             @referencedFields.merge referencedFields
             @twbRootFields.merge dsRootFields
             if @doGraph
-              cypher     @twb.name
-              cypherPy   @twb.name
+              # cypher     @twb.name
+              # cypherPy   @twb.name
             end
             emit "#######################"
             #--
@@ -330,49 +309,49 @@ DOTHEADER
             emit "\t       formula:: #{calculation.formulaFlat}"
           end
 
-          def mapTwb 
-            twb        = @twb.name
-            rootFields = @twbRootFields
-            dotStuff    = initDot twb
-            dotFile     = dotStuff[:file]
-            dotFileName = dotStuff[:name]
-            dotFile.puts "\n //  subgraph cluster_1 {"
-            dotFile.puts "   //    color= grey;"
-            dotFile.puts ""
-            edgesAsStrings = SortedSet.new
-            # this two step process coalesces the edges into a unique set, avoiding duplicating the dot
-            # file entries, and can be shrunk when graph edges expose the bits necessary for management by Set
-            emit "\n========================\nLoading Edges\n========================\n  From DC?  Referenced?  Edge \n  %s  %s  %s" % ['--------', '-----------', '-'*45]
-            @edges.each do |e|
-              # don't want to emit edge which is from a Data Connection to a
-              # Calculated Field which is also referenced by another calculated field
-              isFromDC   = e.from.type == :TwbDataConnection
-              isRefField = @referencedFields.include?(e.to.id)
-              edgesAsStrings.add(e.dot) unless isFromDC && isRefField
-              # emit "   ES        #{e.dot}"
-              # emit "   ES  from  #{e.from}"
-              # emit "   ES    to  #{e.to}"
-            end
-            emit "------------------------\n "
-            edgesAsStrings.each do |es|
-              dotFile.puts "        #{es}"
-            end
-            emit "========================\n "
-            dotFile.puts ""
-            dotFile.puts "   // }"
-            dotFile.puts "\n\n  //  4 NODES --------------------------------------------------------------------"
-            @nodes.each do |n|
-              dotFile.puts n.dotLabel
-            end
-            dotFile.puts "\n\n  //  5--------------------------------------------------------------------"
-            emitTypes(      dotFile )
-            closeDot(       dotFile, twb )
-            emit "Rendering DOT file - #{twb}"
-            renderDot(twb,dotFileName,'pdf')
-            renderDot(twb,dotFileName,'png')
-            renderDot(twb,dotFileName,'svg')
-            # emitEdges
-          end
+          # def mapTwb 
+          #   twb        = @twb.name
+          #   rootFields = @twbRootFields
+          #   dotStuff    = initDot twb
+          #   dotFile     = dotStuff[:file]
+          #   dotFileName = dotStuff[:name]
+          #   dotFile.puts "\n //  subgraph cluster_1 {"
+          #   dotFile.puts "   //    color= grey;"
+          #   dotFile.puts ""
+          #   edgesAsStrings = SortedSet.new
+          #   # this two step process coalesces the edges into a unique set, avoiding duplicating the dot
+          #   # file entries, and can be shrunk when graph edges expose the bits necessary for management by Set
+          #   emit "\n========================\nLoading Edges\n========================\n  From DC?  Referenced?  Edge \n  %s  %s  %s" % ['--------', '-----------', '-'*45]
+          #   @edges.each do |e|
+          #     # don't want to emit edge which is from a Data Connection to a
+          #     # Calculated Field which is also referenced by another calculated field
+          #     isFromDC   = e.from.type == :TwbDataConnection
+          #     isRefField = @referencedFields.include?(e.to.id)
+          #     edgesAsStrings.add(e.dot) unless isFromDC && isRefField
+          #     # emit "   ES        #{e.dot}"
+          #     # emit "   ES  from  #{e.from}"
+          #     # emit "   ES    to  #{e.to}"
+          #   end
+          #   emit "------------------------\n "
+          #   edgesAsStrings.each do |es|
+          #     dotFile.puts "        #{es}"
+          #   end
+          #   emit "========================\n "
+          #   dotFile.puts ""
+          #   dotFile.puts "   // }"
+          #   dotFile.puts "\n\n  //  4 NODES --------------------------------------------------------------------"
+          #   @nodes.each do |n|
+          #     dotFile.puts n.dotLabel
+          #   end
+          #   dotFile.puts "\n\n  //  5--------------------------------------------------------------------"
+          #   emitTypes(      dotFile )
+          #   closeDot(       dotFile, twb )
+          #   emit "Rendering DOT file - #{twb}"
+          #   renderDot(twb,dotFileName,'pdf')
+          #   renderDot(twb,dotFileName,'png')
+          #   renderDot(twb,dotFileName,'svg')
+          #   # emitEdges
+          # end
 
           def cypher twbName
             if @doGraph
@@ -488,44 +467,44 @@ DOTHEADER
             dotFile.puts '   }'
           end
 
-          def initDot twb
-            dotFileName = docFile("#{twb}#{@@processName}.dot")
-            dotFile = File.open(dotFileName,'w')
-            dotFile.puts @@dotHeader
-            return {:file => dotFile, :name => dotFileName}
-          end
+          # def initDot twb
+          #   dotFileName = docFile("#{twb}#{@@processName}.dot")
+          #   dotFile = File.open(dotFileName,'w')
+          #   dotFile.puts @@dotHeader
+          #   return {:file => dotFile, :name => dotFileName}
+          # end
 
-          def closeDot dotFile, twb
-            dotFile.puts ' '
-            dotFile.puts '// -------------------------------------------------------------'
-            dotFile.puts ' '
-            dotFile.puts '   subgraph cluster_1 {'
-            # dotFile.puts '     color=white;'
-            dotFile.puts '     style=invis;'
-            # dotFile.puts '     border=0;'
-            dotFile.puts '     node [border=blue];'
-            dotFile.puts ' '
-            dotFile.puts '     "" [style=invis]'
-            dotFile.puts "     \"Tableau Tools\\nCalculated Fields Map\\nWorkbook '#{twb}'\\n#{Time.new.ctime}\"  [penwidth=0]"
-            # dotFile.puts "     \"Tableau Tools Workbook  Calculated Fields Map\\n#{Time.new.ctime}\"  -> \"\"  [style=invis]"
-            dotFile.puts ' '
-            dotFile.puts '   }'
-            dotFile.puts ' '
-            dotFile.puts '}'
-            dotFile.close
-          end
+          # def closeDot dotFile, twb
+          #   dotFile.puts ' '
+          #   dotFile.puts '// -------------------------------------------------------------'
+          #   dotFile.puts ' '
+          #   dotFile.puts '   subgraph cluster_1 {'
+          #   # dotFile.puts '     color=white;'
+          #   dotFile.puts '     style=invis;'
+          #   # dotFile.puts '     border=0;'
+          #   dotFile.puts '     node [border=blue];'
+          #   dotFile.puts ' '
+          #   dotFile.puts '     "" [style=invis]'
+          #   dotFile.puts "     \"Tableau Tools\\nCalculated Fields Map\\nWorkbook '#{twb}'\\n#{Time.new.ctime}\"  [penwidth=0]"
+          #   # dotFile.puts "     \"Tableau Tools Workbook  Calculated Fields Map\\n#{Time.new.ctime}\"  -> \"\"  [style=invis]"
+          #   dotFile.puts ' '
+          #   dotFile.puts '   }'
+          #   dotFile.puts ' '
+          #   dotFile.puts '}'
+          #   dotFile.close
+          # end
 
 
-          def renderDot twb, dot, format
-            imageType = '-T' + format
-            imageFile  = './ttdoc/' + twb + @@processName + 'Graph.' + format
-            imageParam = '-o"' + imageFile + '"'
-            emit  "system  #{@@gvDotLocation} #{imageType} #{imageParam} \"#{dot}\""
-                   system "#{@@gvDotLocation} #{imageType} #{imageParam} \"#{dot}\""
-            emit  "           - #{imageFile}"
-            @imageFiles << imageFile
-            return imageFile
-          end
+          # def renderDot twb, dot, format
+          #   imageType = '-T' + format
+          #   imageFile  = './ttdoc/' + twb + @@processName + 'Graph.' + format
+          #   imageParam = '-o"' + imageFile + '"'
+          #   emit  "system  #{@@gvDotLocation} #{imageType} #{imageParam} \"#{dot}\""
+          #          system "#{@@gvDotLocation} #{imageType} #{imageParam} \"#{dot}\""
+          #   emit  "           - #{imageFile}"
+          #   @imageFiles << imageFile
+          #   return imageFile
+          # end
 
   end #  class