twb 4.9.2 → 5.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 593542dc199a3eb14583db83dabd812e7aa431e630a7bd37814d8c48723e7978
-  data.tar.gz: d57f4a3077c498ab4bd3eb9a58a8daff981f8c16a30e74bd4103024767f79f0d
+  metadata.gz: f839625abecd6c9b4ad520856fd216678790a2dace5307e62458db4e07b970cd
+  data.tar.gz: f95701f60e3f4f99525113e723392b1d039b361db9ac63eb2689c58ef4a3a490
 SHA512:
-  metadata.gz: b7f2ae59171211a551e2214ea2787b0132c3426e86be43803c58e797a3835b99715b01501f1d70f9ae8305777ec315634e567a7c5556a123f4583065bf8e2afa
-  data.tar.gz: 4f181bf7dbcb73525c49421a73560987ced3b0438b9519debbe0c752bef95bda770eb53b80a73edd00c403c30c5e163a712a91ae4a54b0ec933c1c9e7b806bd2
+  metadata.gz: d59954bb21cc6b232402d0792219df4e0e48ddcf8a664088b58409c7e28b30175f3f3304910459304f2d87639bf1ce5a6f7d9b533b43ed0088bfbb1c4f131c8f
+  data.tar.gz: c8fa036df0e3e8808f507404f5930a8db20ca19fb7a04251eda1deee7dc1ea09f1e06a811f79539275d2eed9cb473f009239dca5ae1c56c7179f4826ed0201c0

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

@@ -73,12 +73,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.2'
+  VERSION = '5.1.4'
 end

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

@@ -249,47 +249,62 @@ 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
                                           ]
+
+
+                    # 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
+                            # @csvFormulaFields <<  [ 
+                            #                         @referencedFieldsCount += 1,
+                            #                         @twb.name,
+                            #                         # @modTime,
+                            #                         ds.uiname,
+                            #                         calcField.uiname,
+                            #                         calculation.formulaFlat,
+                            #                         calculation.formulaFlatResolved,
+                            #                         rf.name,
+                            #                         rf.uiname,
+                            #                         rf.id,
+                            #                         refFieldTable
+                            #                       ]
                   end # resolvedFields.each do
               end # if calculation.has_formula
             end # ds.calculatedFields.each 
@@ -298,8 +313,8 @@ DOTHEADER
             @referencedFields.merge referencedFields
             @twbRootFields.merge dsRootFields
             if @doGraph
-              cypher     @twb.name
-              cypherPy   @twb.name
+              # cypher     @twb.name
+              # cypherPy   @twb.name
             end
             emit "#######################"
             #--

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

@@ -0,0 +1,6 @@
+require 'twb'
+
+twb = Twb::Workbook.new 'MS.twb'
+ds  = twb.datasources.to_a.last
+cfs =  ds.calculatedFields
+cfs.each { |cf|  puts "\n\n--\n#{cf.calculation.formula}\n--"; cf.calcFields.each { |f| puts "   %-12s %s " % [f[:ds], f[:field] ] } }

data/lib/twb/analysis/datasources/datasourcefilesanalyzer.rb

@@ -14,6 +14,7 @@
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'csv'
+require 'pry'
 
 module Twb
 module Analysis
@@ -32,6 +33,7 @@ module DataSources
                           'Data Source', 
                           'File Name', 
                           'File Dir',
+                          'File Exists?',
                           'File Modified',
                           'File Size'
                         ]
@@ -55,7 +57,7 @@ module DataSources
 
       def processTWB twb
         @twbName = twb.name
-        @twDir   = twb.dir
+        @twbDir  = twb.dir
         twb.datasources.each do |ds|
           processFiles ds
         end
@@ -69,9 +71,10 @@ module DataSources
             fqFileName  = twbFileDir.nil? ?  twbFileName : twbFileDir + '/' + twbFileName
             fileName = File.basename fqFileName
             fileDir  = File.dirname  fqFileName
-            modtime  = File.mtime    fqFileName
-            size     = File.size     fqFileName
-            data = [$recNum+=1, twbName, twb.dir, ds.uiname, fileName, fileDir, modtime, size]
+            exists   = File.exist?   fqFileName
+            modtime  = exists ? File.mtime(fqFileName) : nil
+            size     = exists ? File.size(fqFileName)  : nil
+            data = [@recNum+=1, @twbName, @twbDir, ds.uiname, fileName, fileDir, exists, modtime, size]
             @csvFile  << data
         end
       end

data/lib/twb/analysis/sheets/dashboardsummarizer.rb

@@ -0,0 +1,94 @@
+#  sheetfieldsanalyzer.rb Copyright (C) 2018  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 'twb'
+require 'csv'
+
+module Twb
+module Analysis
+
+  class DashboardsSummarizer
+
+    include TabTool
+
+    attr_accessor :localEmit
+
+    def initialize(**args)
+      @args      = args
+      @recordDir = !@args.nil? && @args[:recordDir] == true
+      @ttdocdir  = @args[:ttdocdir]
+      @csvAdd    = !@args.nil? && args[:csvMode] == :add
+      @csvMode   = @csvAdd ? 'a' : 'w'
+      init
+      @funcdoc   = {:class=>self.class, :blurb=>'Analyze Dashboard Worksheets', :description=>'Identifies the Worksheets present in Dashboards.',}
+      #--
+      docFileName     = docFile('DashboardSummaries.csv')
+      @dashboardsCSV  = CSV.open(docFileName,@csvMode)
+      unless @csvAdd
+        if @recordDir
+          @dashboardsCSV  << ['Rec #','Workbook','Dashboard','# Worksheets','Workbook Dir']
+        else
+          @dashboardsCSV  << ['Rec #','Workbook','Dashboard','# Worksheets'               ]
+        end
+      end
+      addDocFile @dashboardsCSV, docFileName, "Workbooks and their Dashboards' summaries"
+      #--
+      @twbCount    = 0
+      @dashCount   = 0
+      @recNum      = 0
+    end
+
+    def metrics
+      {
+        # '# of Workbooks'  => @twbCount,
+        '# of Dashboards' => @dashCount,
+      }
+    end
+
+    def processTWB twb
+       @twb     = twb
+       @twbName = @twb.name
+       @twbDir  = @twb.dir
+       @modTime = @twb.modtime
+       emit "   -- #{@twbName}"
+       @twbCount += 1
+       parseDashes
+       finis
+    end
+
+    def parseDashes
+      @dashboards = @twb.dashboards
+      @dashboards.each do |dash|
+        emit "DASH:: #{dash.name}"
+        @dashCount += 1
+        recordCSV [@twbName, dash.name, dash.worksheets.length]
+      end
+    end
+
+    private
+
+      def recordCSV record
+        numberedRec = [@recNum+=1] + record
+        if @recordDir
+          @dashboardsCSV  << numberedRec.push(@twbDir)
+        else
+          @dashboardsCSV  << numberedRec
+        end
+      end
+
+  end #class SheetFieldsAnalyzer
+
+end # module Analysis
+end # module Twb

data/lib/twb/analysis/workbooksummaryanalyzer.rb

@@ -37,7 +37,7 @@ module Analysis
       docFileName  = docFile('WorkbookSummary.csv')
       @csvFile     = CSV.open(docFileName,@csvMode)
       unless @csvAdd
-        csvHeader       = ['Rec #', 'Workbook','Type','Version','Build','Platform','Modified','# Data Sources','# Dashboards','# Worksheets']
+        csvHeader       = ['Rec #', 'Workbook','Directory','Type','Version','Build','Platform','Modified','# Data Sources','# Dashboards','# Worksheets']
         if @recordDir
           csvHeader.push('Workbook Directory')
         end
@@ -65,6 +65,7 @@ module Analysis
        @twb     = twb
        emit "   -- #{@twbName}"
        recordCSV [ @twb.name,
+                   @twb.dir, 
                    @twb.type, 
                    @twb.version, 
                    @twb.build,

data/lib/twb/calculatedfield.rb

@@ -1,4 +1,4 @@
-#  Copyright (C) 2014, 2015, 2017  Chris Gerrard
+#  Copyright (C) 2014, 2015, 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
@@ -26,7 +26,7 @@ module Twb
     attr_reader :node,        :properties
     attr_reader :caption,     :name,       :uiname
     attr_reader :datatype,    :role,       :propType  
-    attr_reader :calculation, :calcFields 
+    attr_reader :calculation, :referencedFields 
     attr_reader :isGroup,     :groupMembers
     attr_reader :hidden
 
@@ -52,8 +52,8 @@ module Twb
       @properties ||= loadProperties
     end
 
-    def calcFields
-        @calculation.calcFields
+    def referencedFields
+        @calculation.referencedFields
     end
 
     def formulaLines

data/lib/twb/columnfield.rb

@@ -14,6 +14,7 @@
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'nokogiri'
+require 'pry'
 
 module Twb
 
@@ -85,7 +86,6 @@ module Twb
       @aggregation        = load 'aggregation'
       @autoColumn         = load 'auto-column'
       @datatypeCustomized = load 'datatype-customized'
-      # @calcField          = loadCalcField
     end
 
     def id
@@ -94,7 +94,7 @@ module Twb
 
     def load nodeName
       attr = @node.attribute(nodeName)
-      val  = attr.nil? ? nil : attr.text.strip.gsub(/^\[|\]$/,'')
+      val  = attr.nil? ? nil : attr.text.strip
       return val
     end
 

data/lib/twb/datasource.rb

@@ -56,7 +56,7 @@ module Twb
     attr_reader :tableFieldsMap
     attr_reader :fieldUINames
     attr_reader :aliases
-    attr_reader :calculatedFields, :calculatedFieldNamesMap, :calculatedFieldNames, :calculatedField 
+    attr_reader :calculatedFields, :calculatedFieldsMap, :calculatedFieldNames, :calculatedField 
     attr_reader :allFields 
     attr_reader :groups 
     attr_reader :filters
@@ -391,40 +391,6 @@ module Twb
       return @fieldUINames
     end
 
-    def loadFieldUINames
-      # puts 'loadFieldUINames'
-      @fieldUINames = {}
-      # puts 'metadataFields'
-      metadataFields.each do |fld|
-        # puts " - name:%-45s   |  uiname:%-45s   |  localName:%-45s " % [ "'#{fld.name}'", "'#{fld.uiname}'", "'#{fld.localName}'"]
-        @fieldUINames[fld.uiname]    = fld.uiname
-        @fieldUINames[fld.localName] = fld.uiname unless  fld.localName.nil?
-        @fieldUINames[fld.name]      = fld.uiname unless  fld.name.nil?
-      end
-      # puts 'calculatedFields'
-      calculatedFields.each do |fld| 
-        # puts " - name:%-45s   |  uiname:%-45s " % [ "'#{fld.name}'", "'#{fld.uiname}'"]
-        @fieldUINames[fld.name]   = fld.uiname
-        @fieldUINames[fld.uiname] = fld.uiname
-      end
-      # puts 'localFields'
-      localFields.each do |fld|
-        # puts " - name:%-45s   |  uiname:%-45s " % [ "'#{fld.name}'", "'#{fld.uiname}'"]
-        @fieldUINames[fld.name]   = fld.uiname
-        @fieldUINames[fld.uiname] = fld.uiname
-      end
-      # puts "columnFields: #{columnFields.length}"
-      columnFields.each do |fld|
-        @fieldUINames[fld.name]   = fld.uiname
-        @fieldUINames[fld.uiname] = fld.uiname
-      end
-      groups.each do |fld|
-        @fieldUINames[fld.name]   = fld.uiname
-        @fieldUINames[fld.uiname] = fld.uiname
-      end
-      return @fieldUINames
-    end
-
     def tableFields
       @tableFieldsMap.values
     end
@@ -482,8 +448,7 @@ module Twb
 
     def loadAllFields
       @allFields = SortedSet.new
-      dbf = dbFields
-      @allFields << dbf
+      @allFields << dbFields
       @allFields << calculatedFieldNames
     end
 
@@ -532,6 +497,53 @@ module Twb
 
     private
 
+    def loadFieldUINames
+      @fieldUINames = {}
+       # puts"metadataFields: #{metadataFields.length}"
+      metadataFields.each do |fld|
+         # puts" - name:%-45s   |  caption:%-45s   |  uiname:%-45s " % [ "'#{fld.name}'",  "'#{fld.caption}'", "'#{fld.uiname}'"]
+        unless fld.name.nil?
+          @fieldUINames[fld.uiname]    = fld.uiname
+          @fieldUINames[fld.localName] = fld.uiname unless  fld.localName.nil?
+          @fieldUINames[fld.name]      = fld.uiname
+        end
+      end
+       # puts"localFields: #{localFields.length}"
+      localFields.each do |fld|
+         # puts" - name:%-45s   |  caption:%-45s   |  uiname:%-45s " % [ "'#{fld.name}'",  "'#{fld.caption}'", "'#{fld.uiname}'"]
+        unless fld.caption.nil?
+          @fieldUINames[fld.name]   = fld.caption
+          @fieldUINames[fld.uiname] = fld.caption
+        end
+      end
+       # puts"groups: #{groups.length}"
+      groups.each do |fld|
+         # puts" - name:%-45s   |  caption:%-45s   |  uiname:%-45s " % [ "'#{fld.name}'",  "'#{fld.caption}'", "'#{fld.uiname}'"]
+        unless fld.caption.nil?
+          @fieldUINames[fld.name]   = fld.caption
+          @fieldUINames[fld.uiname] = fld.caption
+        end
+      end
+       # puts"calculatedFields: #{calculatedFields.length}"
+      calculatedFields.each do |fld| 
+         # puts" - name:%-45s   |  caption:%-45s   |  uiname:%-45s " % [ "'#{fld.name}'",  "'#{fld.caption}'", "'#{fld.uiname}'"]
+        unless fld.caption.nil?
+          @fieldUINames[fld.name]   = fld.caption
+          @fieldUINames[fld.uiname] = fld.caption
+        end
+      end
+       # puts"columnFields: #{columnFields.length}"
+      columnFields.each do |fld|
+         # puts" - name:%-45s   |  caption:%-45s   |  uiname:%-45s " % [ "'#{fld.name}'",  "'#{fld.caption}'", "'#{fld.uiname}'"]
+        unless fld.caption.nil?
+          # @fieldUINames[fld.name]                          = fld.caption
+          @fieldUINames[fld.name.gsub(/^[\[]|[\]]$/,'')]   = fld.caption
+          @fieldUINames[fld.uiname]                        = fld.caption
+        end
+      end
+      return @fieldUINames
+    end
+
     def loadGroups
       @groups = []
       groupNodes = @node.xpath('.//group')

data/lib/twb/fieldcalculation.rb

@@ -16,6 +16,7 @@
 require 'nokogiri'
 require 'digest/md5'
 require 'csv'
+require 'pry'
 
 module Twb
 
@@ -35,7 +36,7 @@ module Twb
     attr_reader :is_tableCalc
     attr_reader :is_lod,   :lodCodePos
     attr_reader :class,    :scopeIsolation
-    attr_reader :fields,   :remoteFields,  :calcFields
+    attr_reader :fields,   :remoteFields, :referencedFields
     attr_reader :comments, :uuid
 
     # attr_accessor :ttlogfile
@@ -120,59 +121,29 @@ module Twb
     end
 
     def formulaResolved
-      @formulaResolved ||= @formulaResolved = resolveFormula
+      @formulaResolved ||= resolveFormula
     end
     
     def resolveFormula
       # puts "\ndef resolveFormula:\n--\n#{@formula}"
       formula = @formula
-      parseFormFields # - extracts the fields from the formula; as persisted they're the internal names
-      @calcFields.each do |calcField|
-        if calcField.techUIdiff
-         # puts ":::: #{calcField.techCode}  //  #{calcField.uiCode}"
-          formula = formula.gsub(calcField.techCode,calcField.uiCode)
-         # puts ":--: #{formula}"
-        end
+      # parseFormFields # - extracts the fields from the formula; as persisted they're the internal names
+      referencedFields.each do |calcField|
+      #   if calcField.techUIdiff
+      #    # puts ":::: #{calcField.techCode}  //  #{calcField.uiCode}"
+      #     formula = formula.gsub(calcField.techCode,calcField.uiCode)
+      #    # puts ":--: #{formula}"
+      #   end
       end
       return formula
     end
 
-    def calcFields
-      @calcFields ||= parseFormFields
+    def referencedFields
+      @referencedFields ||= parseFormFields
     end
 
-    def parseFormFields
-      # puts "--parseFormFields"
-      @fields     = Set.new    
-      @calcFields = Set.new
-      formula = @formulaFlat
-      if !formula.nil? && formula.include?('[') && formula.include?(']')
-          fields   = Set.new
-          # noSqLits =  formula.gsub( /'[\[\.\]]+'/, ' ')
-          quotes   =  formula.gsub('"',"'")
-          noSqLits =   quotes.gsub( /'[\[\.\]]+'/, ' ')
-          flatForm = noSqLits.gsub( /\n/, ' ')
-          stripFrt = flatForm.gsub( /^[^\[]*[\[]/    , '['      )
-          stripBck = stripFrt.gsub( /\][^\]]+$/      , ']'      )
-          stripMid = stripBck.gsub( /\][^\]]{2,}\[/  , ']]..[[' )
-          stripCom = stripMid.gsub( /\][ ]*,[ ]*\[/  , ']]..[[' )
-          stripFns = stripMid.gsub( /\][ ]*[\*\/+\-><,=][ ]*\[/  , ']]..[[' )
-          fields   = stripFns.split(']..[')
-          emit "::self::: #{self} :: #{__LINE__} :: fields:'#{fields.inspect}'" 
-          fields.each do |field|
-            emit "::self::: #{self} :: #{__LINE__} :: field:'#{field}'" 
-            cf = CalculationField.new( field.gsub(/^\[|\]$/, ''), @dataSource )
-            @calcFields.add cf
-            @fields.add field.gsub(/^\[|\]$/, '')
-          end
-      end
-      return @calcFields
-    end
 
     def formulaResolvedLines
-      # puts "\ndef formulaResolvedLines\n--\n#{formulaResolved}"
-      # puts "--\n#{formulaResolved.split(/\n|\r\n/)}"
-      # puts "--\n#{formulaResolved.split(/\n|\r\n/)}"
       formulaResolved.split(/\n|\r\n/)
     end
 
@@ -212,11 +183,149 @@ module Twb
       return comments.strip
     end
 
-  end  # class FieldCalculation
+    private
 
 
+    def pullString chars
+      delim1 = chars.shift
+      delim2 = delim1+delim1
+      field  = delim1
+      done   = false
+      until done | chars.empty?
+        s01 = chars[0..1].join
+        if !delim1.eql? chars[0]
+          field += chars.shift
+        else
+          case s01
+          when delim2
+            field += delim2
+            chars.shift(2)
+          when delim1
+            field += delim1
+            chars.shift
+            done = true
+          else
+            field += delim1
+            chars.shift
+            done = true
+          end
+        end
+      end
+    end
+
+    def pullField chars
+      # chars = str.split ''
+      done  = false
+      ds    = ''
+      field = ''
+      until done
+        s01 = chars[0..1].join
+        s02 = chars[0..2].join
+        if ']'.eql? chars[0]
+          case s01
+          when ']]'
+            field += ']]'
+            chars.shift(2)
+          when ']'
+            field += chars.shift
+            done = true
+          else
+            if '].['.eql?(s02)
+              ds = field + ']'
+              chars.shift(2)
+              # fldstr   = chars.join
+              field    = pullField(chars)[:field]
+              done     = true
+            else
+              field += ']'
+              chars.shift
+              done = true
+            end
+          end
+        else
+          field += chars[0]
+          chars.shift
+        end
+      end
+      # puts "field: '#{field}' \t\t ds: #{ds}"
+      return {:field => field.sub(/\[/,'').sub(/\]$/,''), :ds => ds.sub(/\[/,'').sub(/\]$/,'') }
+    end
 
-  class CalculationField
+    def parseFormFields # formula
+      @referencedFields = Array.new
+      rawFields         = Array.new
+      if !@formula.nil? && @formula.include?('[') && @formula.include?(']')
+      chars  = formula.split('')
+      until chars.empty?
+        char0 = chars[0]
+        case char0
+        when '"', "'"
+          pullString(chars)
+        when '['
+          rawFields << pullField(chars)
+        else
+          unless chars.nil? | chars.empty?
+            chars.shift
+          end
+        end
+      end
+      rawFields.each do |rf|
+        ds = rf[:ds]
+        dataSource = if ''.eql? ds
+                       @dataSource
+                     else 
+                       @dataSource.workbook.datasource(ds)
+                     end
+        # fieldUIName = dataSource.fieldUIName(rf[:field])
+        refField    = ReferencedField.new(rf[:field], dataSource)
+        @referencedFields << refField
+        end
+      end
+      return @referencedFields
+    end
+
+    def parseFormFieldsx # formula
+      rawFields = Set.new
+      if !@formula.nil? && @formula.include?('[') && @formula.include?(']')
+        noComms   = @formula.gsub(/\/\/.*\r\n/,' ')
+        formBase  = noComms.gsub(/\r\n/,' ')
+        formLen   = formBase.length
+        formChars = formBase.split '' 
+        until formChars.empty?
+          c = formChars.shift
+          case c
+            when '"', "'"  
+              pullString(formChars, c)
+            when '['       
+              rawFields << pullField(formChars, ']', @referencedFields)
+          end
+        end
+      end
+      @referencedFields = Set.new
+      rawFields.each do |rf|
+        # @referencedFields << rf
+        dataSource = if ''.eql? rf[:ds]
+                       @dataSource
+                     else 
+                       @dataSource.workbook.datasource(rf[:ds])
+                     end
+        # if dataSource.nil?
+        #   binding.pry
+        # end
+        fieldUIName = dataSource.fieldUIName(rf[:field])
+        # binding.pry
+        refField = ReferencedField.new(rf[:field], dataSource)
+        # binding.pry
+        @referencedFields << refField
+      end
+      return @referencedFields
+    end
+
+  end  # class FieldCalculation
+
+
+  # class CalculationField
+  class ReferencedField
     # is a field used in a calculation, resolved into its human-meaningful form
 
     include Comparable
@@ -228,65 +337,29 @@ module Twb
     attr_reader :fqName,     :type
     attr_reader :techUIdiff
 
-    def initialize code, datasource
-      # puts "\n\nCalculationField ::  %-25s  |  %s  " % [datasource.uiname, code]
+    def initialize name, datasource
+      # puts "\n\nReferencedField ::  ds: %-25s  |  n: %s  " % [datasource, name]
+      @name             = name
       @dataSource       = datasource
-      @dataSourceName   = datasource.uiname
+      @dataSourceName   = datasource.nil? ? nil : datasource.uiname
       @dataSourceRef    = :local
       @dataSourceExists = true
+      @techCode         = "[#{name}]"
       @techUIdiff       = false
-      @uiname           = ''
-      rawCode  = code.gsub(/^\[|\]$/,'')
-      parts    = rawCode.split('].[')
-      #puts "Field: #{code}  \t parts: #{parts.length} - #{parts.inspect}"
-      if parts.length == 1
-        @name = parts[0]
-        @techCode = "[#{parts[0]}]"
-        #puts "@name: #{@name}"
-        if datasource.nil?
-          # puts 'a'
-          @uiname = @name
-          @uiCode = @techCode
-          @techUIdiff = false
-        else # !datasource.nil?
-          # puts 'b'
-          #puts "b - found uiname for '#{@name}'?: #{!datasource.fieldUIName(@name).nil?} \t is:#{datasource.fieldUIName(@name)} "
-          @uiname = datasource.fieldUIName(@name).nil? ? @name : datasource.fieldUIName(@name) 
-          @uiCode = @uiname.nil? ? @techCode :  "[#{@uiname}]"
-          @techUIdiff = !@techCode.eql?(@uiCode)
-          # puts ":b #{datasource.fieldUIName(@name).nil?}  ... #{@name}  ... #{@uiname}"
-          # puts "CalculationField ::       uin: %-25s | @name:%-s" % [@uiname,@name]
-        end
-      else # parts.length <> 1
-        # puts 'c'
-        rdstech   = parts[0]
-        calcField = parts[1]
-        @uiname   = calcField
-        @dataSourceName = rdstech
-        @dataSourceRef  = :remote
-        @techCode = "[#{rdstech}].[#{calcField}]"
-        workbook  = datasource.workbook
-        @dataSource  = workbook.nil? ? nil : workbook.datasource(rdstech)
-       # puts "\t  twb: #{workbook.class}  /  remoteds: #{remoteds.class}  : #{remoteds.nil? ? "<<NOT FOUND:#{rdstech}:>>" : remoteds.uiname} "
-        #--
-        if @dataSource.nil? || @dataSource.fieldUIName(calcField).nil?
-          # puts 'd'
-          @uiname     = calcField
-          @uiCode     = "[<<NOT FOUND>>#{rdstech}].[#{calcField}]"
-          @techUIdiff = true
-          @dataSourceExists = false
-        else  # !remoteds.nil?
-          # puts 'e'
-          @dataSourceName = @dataSource.uiname
-          @uiname         = @dataSource.fieldUIName(calcField)
-          @uiCode         = "[#{@dataSourceName}].[#{@uiname}]"
-          @techUIdiff     = !@techCode.eql?(@uiCode)
-          @dataSourceExists = true
-        end
+      if dataSource.nil?
+        # puts 'a'
+        @uiname = @name
+        @uiCode = @techCode
+        @techUIdiff = false
+      else # !datasource.nil?
+        # puts 'b'
+        # puts "b - found uiname for '#{@name}'?: #{!datasource.fieldUIName(@name).nil?} \t is:#{datasource.fieldUIName(@name)} "
+        @uiname = datasource.fieldUIName(@name).nil? ? @name : datasource.fieldUIName(@name) 
+        @uiCode = @uiname.nil? ? @techCode :  "[#{@uiname}]"
+        @techUIdiff = !@techCode.eql?(@uiCode)
+        # puts ":b #{datasource.fieldUIName(@name).nil?}  ... #{@name}  ... #{@uiname}"
+        # puts "CalculationField ::       uin: %-25s | @name:%-s" % [@uiname,@name]
       end
-      # puts "\t     dsName: #{@dataSourceName}"
-      # puts "\t   @name: #{@name}"
-      # puts "\t     uiname: #{@uiname}"
       @fqName = "#{@dataSourceName}::#{@uiname}"
       @type   = if @dataSource.nil?
                    :CalculatedField
@@ -308,6 +381,6 @@ module Twb
       @fqName <=> other.fqName
     end
 
-  end # class CalculationField
+  end # class ReferencedField
 
 end  # module Twb

data/lib/twb/util/cypher.rb

@@ -26,18 +26,20 @@ module Util
 
 #====================================================================
 
-    attr_accessor :nodes, :edges, :fileName, :fileName
+    attr_accessor :nodes, :edges, :fileName, :mode
     attr_accessor :cleanup
 
     def initialize
       emit "Cypher.initialize"
       @fileName  = 'Neo4jCommands'
+      @mode      = :create
       @nodes     = []
       @edges     = []
       @cleanup   = false
     end
 
     def render
+      puts "Cypher.render"
       @file = File.open(docFile("#{@fileName}.cypher"),'w')
       renderNodes
       renderEdges
@@ -46,6 +48,7 @@ module Util
     end
 
     def renderNodes
+      puts "Cypher def renderNodes @nodes:#{@nodes.to_s}"
       csv = CSV.open(docFile("#{@fileName}.nodes.csv"),'w')
       csv << ['Type','Name','UUID']
       nodesCSV = Set.new
@@ -53,7 +56,7 @@ module Util
       nodesByType = Hash.new { |type,nodes| type[nodes] = [] }
       @nodes.each do |node|
         nodesCSV << [node.type, node.name, node.uuid]
-        nodeCmds << encode('MERGE','node',node,';')
+        nodeCmds << encode(node,';')
         nodesByType[node.type] << node
       end
       if @cleanup
@@ -93,8 +96,12 @@ module Util
       csv.close
     end
 
-    def encode command, varName, node, terminator=''
-      "%-8s (%s:%s { name:'%s', uuid: '%s' } ) %s" % [command, varName, node.type, node.name, node.uuid, terminator ]
+    def encode node, terminator=''
+      puts "def encode node: #{node}  "
+      case @mode
+      when :merge  then "MERGE (%s:%s { name:'%s', uuid: '%s' } ) %s" % [node.uuid, varName, node.type, node.name, terminator ]
+      when :create then "CREATE (#{node.uuid}:#{node.type} {} )"
+      end
     end
 
     def encodeEdge command, varName, node, terminator=''

data/lib/twb/util/gml.rb

@@ -77,10 +77,16 @@ GMLHEADER
 
     def renderNodes file
       nodes = Set.new
+      # puts 'def renderNodes'
       @nodes.each do |node|
         gmlID   = Digest::MD5.hexdigest(node.id)
         gmlName = node.name.gsub('&','&').gsub('"','"')
-        nodes << "node [\n        id    \"#{gmlID}\" \n        label \"#{gmlName}\" \n    ]"
+        nodestr = "node [\n        id    \"#{gmlID}\" \n        label \"#{gmlName}\" "
+        unless node.colour.nil?
+          nodestr += "\n    graphics \n   [ \n      fill  \"#{node.colour}\" \n   ] "
+        end
+        nodestr += "\n    ]"
+        nodes << nodestr
       end
       nodes.each do |node|
         file.puts node

data/lib/twb/util/graphnode.rb

@@ -46,7 +46,7 @@ module Util
                    }
 
     attr_reader   :id, :uuid, :type, :name, :dotid
-    attr_accessor :properties
+    attr_accessor :properties, :colour
 
     def initialize (name:, id:, type:, properties: {})
       # puts "graphNode : t: %-20s  tc: %s " % [type, type.class]
@@ -56,6 +56,7 @@ module Util
       @type         = resolveType type 
       # puts "          : t: %-20s  tc: %s \n " % [@type, @type.class]
       @name         = name
+      @colour       = nil
       @properties   = properties
       @properties['name'] = name unless @properties.key? 'name'
       if @name.nil? 
@@ -117,7 +118,7 @@ module Util
     end
 
     def <=>(other)
-      uuid <=> other.uuid
+      hash <=> other.hash
     end
 
   end # class Graphnode

data/test/testFieldCalculation.rb

@@ -16,7 +16,9 @@
 require 'nokogiri'
 
 #require 'twb'
-require 'C:\tech\Tableau\tools\Ruby\gems\twb\lib\twb.rb'
+# require 'C:\tech\Tableau\tools\Ruby\gems\twb\lib\twb.rb'
+# require 'C:\tech\Tableau\Tableau Tools\Ruby\gems\twb\lib\twb.rb'
+require 'twb'
 require "test/unit"
 
 system "cls"
@@ -25,10 +27,11 @@ class TestFieldCalculation < Test::Unit::TestCase
 
   def test_fragment1
     doc = Nokogiri::XML::Document.parse <<-EOHTML
-<calculation class='tableau' formula='abc' />
+<calculation class='tableau' name='I am a formular field' formula='abc' datatype='datatype' role='' type='' class='calcfield' />
 EOHTML
-    calcNode = doc.at_xpath('./calculation')
-    calc = Twb::FieldCalculation.new(calcNode)
+    calcNode  = doc.at_xpath('./calculation')
+    calcField = Twb::CalculatedField.new calcNode
+    calc = Twb::FieldCalculation.new(calcField)
     assert(!calc.nil?)
     #puts "node: #{calcNode}"
     #puts "formula: #{calc.formula}"
@@ -41,10 +44,11 @@ EOHTML
 
   def test_fragment2
     doc = Nokogiri::XML::Document.parse <<-EOHTML
-        <calculation class='tableau' formula='// this is the number of days between the order and shipment&#13;&#10;&#13;&#10;datediff(&apos;day&apos;,[Order Date] , [other].[Ship Date])' />
+        <calculation class='tableau' name='Another formula fied' formula='// this is the number of days between the order and shipment&#13;&#10;&#13;&#10;datediff(&apos;day&apos;,[Order Date] , [other].[Ship Date])' />
 EOHTML
     calcNode = doc.at_xpath('./calculation')
-    calc = Twb::FieldCalculation.new(calcNode)
+    calcField = Twb::CalculatedField calcNode
+    calc = Twb::FieldCalculation.new(calcField)
     assert(!calc.nil?)
     #puts "node: #{calcNode}"
     #puts "formula: #{calc.formula}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twb
 version: !ruby/object:Gem::Version
-  version: 4.9.2
+  version: 5.1.4
 platform: ruby
 authors:
 - Chris Gerrard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-07 00:00:00.000000000 Z
+date: 2020-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: creek
@@ -58,6 +58,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/t.rb
+- lib/tfl/Flow.rb
 - lib/twb.rb
 - lib/twb/action.rb
 - lib/twb/analysis/annotatedfieldscsvemitter.rb
@@ -66,6 +67,7 @@ files:
 - lib/twb/analysis/calculatedfields/fieldsaliasesanalyzer.rb
 - lib/twb/analysis/calculatedfields/groupfieldsanalyzer.rb
 - lib/twb/analysis/calculatedfields/markdownemitter.rb
+- lib/twb/analysis/calculatedfields/t.rb
 - lib/twb/analysis/datasources/categoricalcolorcodinganalyzer.rb
 - lib/twb/analysis/datasources/datasourcefieldsanalyzer.rb
 - lib/twb/analysis/datasources/datasourcefieldscsvemitter.rb
@@ -82,6 +84,7 @@ files:
 - lib/twb/analysis/documentedfieldscsvemitter.rb
 - lib/twb/analysis/documentedfieldsmarkdownemitter.rb
 - lib/twb/analysis/sheets/analyzedashboardsheets.rb
+- lib/twb/analysis/sheets/dashboardsummarizer.rb
 - lib/twb/analysis/sheets/dashsheetsanalyzer.rb
 - lib/twb/analysis/sheets/sheetfieldsanalyzer.rb
 - lib/twb/analysis/sheets/sheetfiltersanalyzer.rb