twb 1.9.1 → 2.2.1

data/lib/twb/analysis/DocumentedFieldsCSVEmitter.rb

@@ -0,0 +1,208 @@
+#  DocumentedFieldsCSVEmitter.rb - this Ruby script Copyright 2017 Christopher 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 DocumentedFieldsCSVEmitter
+
+    attr_reader :csvFileName, :csvRecords
+    attr_reader :dsCount,     :fieldsCount  
+
+    @@csvHeader = ['Record #',
+                   'Workbook',           
+                   'Workbook Dir',
+                   'Data Source',
+                   'Field',
+                   'Doc Type',
+                   'Doc Line #'
+                   'Doc Line'
+                  ]
+    @@csvFileType = 'TwbAnnotatedFields'
+    @@csvFileName = @@csvFileType + '.csv'
+
+    def initialize
+      @csvFile     = CSV.open(@@csvFileName,'w')
+      @csvFile     << @@csvHeader
+      @csvRecords  = Set.new
+      puts "Opened: #{!@csvFile.nil?} - #{@@csvFileName}"
+      # --
+      @recNum      = 0
+      @dsCount     = 0
+      @fieldsCount = 0
+    end
+
+    def self.csvHeader
+      @@csvHeader
+    end
+
+    def self.csvFileType
+      @@csvFileType
+    end
+
+    def self.csvFileNaame
+      @@csvFileName
+    end
+
+    def processTwb twb
+      @twb = nil
+      @twb         = twb                    if twb.instance_of? Twb::Workbook
+      @twb         = Twb::Workbook.new(twb) if twb.instance_of? String
+      raise ArgumentError.new("ERROR in Workbok processing: '#{twb}' must be a Workbook (class) or the name of a Workbook (String), is a #{twb.class} \n ") unless @twb.is_a? Twb::Workbook
+      # --
+      dss = @twb.datasources
+      dss.each do |ds|
+        @dsname = ds.uiname
+        # puts "\n    -- #{ds.uiname} "
+        # tables = Set.new
+        fields = {}
+        @dsCount += 1
+        fclasses = Set.new
+        ds.localFields.each do |field|
+          recordFieldFull field, :local
+          # recordField( fields, field, {:type=>:local,:columnField=>true,:hidden=>field.hidden} )
+          # emitTech( ds,     field.uiname, 'Local', field.properties)
+          # recordTech( field, 'LocalA')
+        end
+        ds.columnFields.each do |field|
+          recordFieldFull field, :column
+          # recordField( fields, field, {:type=>'column',:columnField=>true,:hidden=>field.hidden} )
+          # emitTech( ds,     field.uiname, 'Column', field.properties)
+          # recordTech( field, 'ColumnA')
+        end
+        ds.calculatedFields.each do |field|
+          recordFieldFull field, :calc
+          # puts "WWW #{field.class}  :: #{field} ::prop:: #{field.properties.class} :: #{field.properties}"
+          # recordField( fields, field, {:type=>'calc',:calculatedField=>true,:hidden=>field.hidden} )
+          # emitTech( ds,     field.uiname, 'Calculated', field.properties)
+          # recordTech( field, 'CalcA')
+        end
+        ds.metadataFields.each do |field|
+          recordFieldFull field, :metadata
+          # recordField( fields, field,   {:type=>'metadata',:metadataField=>true} )
+          # emitTech( ds,     field.uiname, 'MetaData', field.properties)
+          # recordTech( field, 'MetadataA')
+        end
+        ds.dbFields.each do |field|
+          recordFieldFull field, :db
+          # recordField( fields, field,    {:type=>'database',:dbField=>true} )
+          # emitTech( ds,     field.uiname, 'Db', field.properties)
+          # recordTech( field, 'DbA')
+        end
+        ds.mappedFields.each do |field|
+          recordFieldFull field, :mapped
+          # recordField( fields, field,    {:type=>'mapped',:mappedField=>true} )
+          # emitTech( ds,     field.uiname, 'Mapped', field.properties)
+          # recordTech( field, 'MappedA')
+        end
+        emitFields(fields)
+      end
+    end # def processTwb twb
+
+    def recordFieldFull field, source
+      # print field.properties.nil? ? '-' : ":#{field.properties.length}"
+      # puts field.properties
+      @recNum+=1
+      field.properties.each do |name,value|
+        # print name 
+        @csvFileFull << [  @recNum,
+                           @twb.name,
+                           @twb.dir,
+                           @dsname,
+                           field.uiname,
+                           source,
+                           field.class,
+                           field.node.path.to_s.gsub(/[0-9]/,'').gsub('[]',''),
+                           name,
+                           value
+                         ]
+        # @csvFileFull << csvRec
+      end
+    end
+
+    def recordField fields, field, props
+      # puts "%-65s  :: %s " % [fieldName,props]
+      return if field.uiname.nil?
+      if fields.has_key? field.uiname
+        fields[field.uiname].merge! field.properties
+      else
+        fields[field.uiname] = field.properties
+      end
+    end
+
+    def emitFields fields
+      fields.each do |fieldName,props|
+        # puts "FIELD::  %-40s  :: %s" % [fieldName,props.inspect]
+        # class = props[]
+        csvRec = [ @recNum+=1,
+                   @twb.name,
+                   @twb.dir,
+                   @dsname,
+                   fieldName,
+                   props[:type],
+                   props['hidden'],
+                   props[:columnField],
+                   props[:calculatedField],
+                   props[:dbField],
+                   props[:mappedField],
+                   props[:metadataField]
+                 ]
+        @csvFile << csvRec
+        @csvRecords.add csvRec
+      end
+    end
+
+    def recordTech field, type
+      @recNum+=1
+      field.properties.each do |name,value|
+        @csvFileTech << [ @recNum,
+                          @twb.name,
+                          @twb.dir,
+                          @dsname,
+                          field.uiname,
+                          type,
+                          name,
+                          value
+                        ]
+      end
+    end
+
+    def emitTech dataSource, fieldName, type, properties
+      # puts "XX #{dataSource.uiname} :: #{fieldName} #{}  :: #{type} :: #{properties}"
+      @recNum+=1
+      properties.each do |name,value|
+        @csvFileTech << [ @recNum,
+                          @twb.name,
+                          @twb.dir,
+                          dataSource.uiname,
+                          fieldName,
+                          type,
+                          name,
+                          value
+                        ]
+      end
+    end
+
+    def cleanup
+      @csvFile.close unless @csvFile.nil?
+    end
+
+  end # class DocumentedFieldsCSVEmitter
+
+end   # module Analysis
+end   # module Twb

data/lib/twb/analysis/DocumentedFieldsMarkdownEmitter.rb

@@ -0,0 +1,77 @@
+#  calculatedfieldsanalyzer.rb - this Ruby script Copyright 2017 Christopher 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'
+
+module Twb
+module Analysis
+
+  class DocumentedFieldsMarkdownEmitter
+
+    attr_reader :docFileName
+
+    def initialize
+      # puts ""
+    end
+
+    def processTwb twbName
+      @twb = Twb::Workbook.new twbName
+      @docFileName = @twb.name + '.DocumentedFields.md'
+      @docFile     = File.open(@docFileName,'w')
+      @docFile.puts "## #{@twb.name}"
+      dss = @twb.datasources
+      @docFile.puts "#{dss.length} Data Source#{(dss.length>1) ? 's' : ''}"
+      @docFile.puts " "
+      dss.each do |ds|
+        @docFile.puts "- #{ds.uiname}"
+      end
+      @docFile.puts " "
+      dss.each do |ds|
+        @docFile.puts "### #{ds.uiname}"
+        columnFields = ds.columnFields  #.sort_by { |fldName,calc| fldName }
+        columnFields.each do |field|
+          commentLines = field.comment 
+          calculation  = field.calcField
+          # puts "\n#{field.uiname}"
+          # puts "Comment? #{commentLines}"
+          # puts "Calc   ? #{calculation}"
+          @docFile.puts "\n##### #{field.uiname} "
+          unless commentLines.nil?
+            commentLines.each do |line|
+              @docFile.puts "###### #{line}"
+            end
+          end
+          unless calculation.nil?
+            @docFile.puts "```"
+              @docFile.puts calculation.formulaResolved
+              @docFile.puts "\n -- Fields  --" unless calculation.calcFields.empty?
+              refFields = SortedSet.new
+              calculation.calcFields.each do |cf|
+                fds =  if cf.dataSourceRef == :remote then "<<#{cf.dataSource}>>" else '' end
+                refFields.add "#{cf.uiName} \t #{fds}"
+              end
+              refFields.each do |rf|
+                @docFile.puts "    #{rf}"
+              end
+              @docFile.puts "```"
+          end
+        end
+      end
+    end
+
+  end # class MarkdownEmitter
+
+end   # module Analysis
+end   # module Twb

data/lib/twb/calculatedfield.rb

@@ -19,14 +19,16 @@ module Twb
 
   class CalculatedField
 
-    attr_reader :node,     :dataSource
+    attr_reader :dataSource
+    attr_reader :node,     :properties
     attr_reader :caption,  :name, :uiname  
     attr_reader :datatype, :role, :type  
-    attr_reader :calculation
+    attr_reader :calculation, :calcFields
+    attr_reader :hidden
 
     def initialize(calcNode, datasource=nil)
-        @dataSource = datasource
         @node       = calcNode
+        @dataSource = datasource
         # -- 
         @caption    = calcNode.attribute('caption').text if calcNode.has_attribute?('caption')
         @name       = calcNode.attribute('name').text.gsub(/^\[/,'').gsub(/\]$/,'')
@@ -37,6 +39,37 @@ module Twb
         @type        = @node.attribute('type').text
         # -- 
         @calculation = Twb::FieldCalculation.new(self, datasource)
+        # -- 
+        @hidden      = true if calcNode.has_attribute?('caption')
+    end
+
+    def properties
+      @properties ||= loadProperties
+    end
+
+    def calcLines
+        @calculation.calcFields
+    end
+
+    def formulaLines
+        @calculation.formulaLines
+    end
+
+    def formulaResolvedLines
+        @calculation.formulaResolvedLines
+    end
+
+    def formulaResolved
+        @calculation.formulaResolved
+    end
+
+    def loadProperties
+      @properties= {}
+      @node.attributes.each do |name,attr|
+        @properties[name] = attr.value
+      end
+      @properties[:uiname] = @uiname
+      return @properties
     end
 
     def to_s

data/lib/twb/columnfield.rb

@@ -1,4 +1,4 @@
-#  Copyright (C) 2014, 2015  Chris Gerrard
+#  Copyright (C) 2014, 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
@@ -47,15 +47,18 @@ module Twb
     # value
     # visual-totals
 
-    attr_reader :node
+    attr_reader :node,       :properties
     attr_reader :name,       :caption,       :uiname
     attr_reader :dataType,   :defaultFormat, :paramDomainType
     attr_reader :role,       :type,          :value
     attr_reader :alias,      :semanticRole,  :aggregation
     attr_reader :autoColumn, :hidden,        :datatypeCustomized
+    attr_reader :calcField
 
 
-    def initialize fieldNode
+    def initialize(fieldNode, datasource=nil)
+      
+      @datasource         = datasource
       @node               = fieldNode
       @name               = load 'name'
       @caption            = load 'caption'
@@ -73,6 +76,7 @@ module Twb
       @autoColumn         = load 'auto-column'
       @hidden             = load 'hidden'
       @datatypeCustomized = load 'datatype-customized'
+      @calcField          = loadCalcField
     end
 
     def load nodeName
@@ -81,6 +85,69 @@ module Twb
       return val
     end
 
+    def  calcField
+      @calcField ||= loadCalcField
+    end
+
+    def loadCalcField
+      if !@node.at_xpath('./calculation').nil?
+        @calcField = Twb::CalculatedField.new @node, @datasource
+      else 
+        @calcField = nil
+      end
+    end
+
+    def comment
+      @commentLines ||= loadComment
+    end
+
+    # COMMENTED FIELDS
+    # --------------------------------------
+    # <column caption='Calculation1' datatype='real' name='[Calculation_821344020759588865]' role='measure' type='quantitative'>
+    #   <calculation class='tableau' formula='[Formula Length] * 1.1' />
+    #   <desc>
+    #     <formatted-text>
+    #       <run>THIS IS A COMMENT</run>
+    #     </formatted-text>
+    #   </desc>
+    # </column>
+    # <column datatype='string' name='[Data Source Name (tech) (CalculatedFieldsReferencedFields.csv)]' role='dimension' type='nominal'>
+    #   <desc>
+    #     <formatted-text>
+    #       <run>THIS IS A COMMENT</run>
+    #     </formatted-text>
+    #   </desc>
+    # </column>
+    def loadComment
+      @commentLines = []
+      runs = @node.xpath('./desc/formatted-text/run')
+      runs.each do |run|
+        lines = run.text.split(/\n/)
+        lines.each do |line|
+          @commentLines << line
+        end
+      end
+      return @commentLines
+    end
+
+    def hasComment?
+      loadComment if @commentLines.nil?
+      @commentLines.empty?
+    end
+
+    def properties
+      @properties ||= loadProperties
+    end
+
+    def loadProperties
+      @properties= {}
+      @node.attributes.each do |name,attr|
+        @properties[name] = attr.value
+      end
+      @properties[:uiname] = @name
+      return @properties
+    end
+
     def to_s
       @name
     end

data/lib/twb/datasource.rb

@@ -48,6 +48,7 @@ module Twb
     attr_reader :metadataFields 
     attr_reader :dbFields
     attr_reader :mappedFields
+    attr_reader :tableFieldsMap
     attr_reader :fieldUINames
     attr_reader :calculatedFields, :calculatedFieldNamesMap, :calculatedFieldNames, :calculatedField 
     attr_reader :allFields 
@@ -59,7 +60,7 @@ module Twb
       @workbook = workbook 
       @name     = @node.attr('name')
       @caption  = @node.attr('caption')
-      @uiname   = if @caption.nil? || @caption == '' then @name else @caption end
+      @uiname   = @caption.nil? ? @name : @caption
       processConnection
       processFilters
       loadTableFields
@@ -150,7 +151,6 @@ module Twb
         table = code.split('].[')[0][1..-1]
     end
 
-
     def Parameters?
       'Parameters'.eql? @name 
     end
@@ -159,22 +159,30 @@ module Twb
       @columnFields ||= loadColumnFields
     end
 
+    def columnFieldsMap
+      loadColumnFields if @columnFieldsMap.nil?
+      return @columnFieldsMap
+    end
+
     def loadColumnFields
-      @columnFields = Set.new
+      @columnFields    = Set.new
+      @columnFieldsMap = {}
       nodes = @node.xpath('./column')
       nodes.each do |n|
-        field = Twb::ColumnField.new n
+        field = Twb::ColumnField.new n, self
         @columnFields << field
+        @columnFieldsMap[field.uiname] = field
       end
       return @columnFields
     end 
 
+
     def localFields
       @localFields ||= loadLocalFields
     end
 
     def loadLocalFields
-      @localFields = {}
+      @localFields = Set.new
       unless @connection.nil?  # Parameters has no connection node, & no local fields
         connClass    = @node.at_xpath('./connection').attribute('class').text
         fxpath       = case connClass
@@ -185,7 +193,7 @@ module Twb
         nodes = @node.xpath(fxpath)
         nodes.each do |node|
           field = Twb::LocalField.new(node)
-          @localFields[field.name] = field
+          @localFields << field
         end
       end
       return @localFields
@@ -201,7 +209,7 @@ module Twb
         # nodes = @node.xpath(".//metadata-record[@class='column']")
         # # note: there are other nodes "<metadata-record class='capability'>" whose nature is unclear
         # #       these nodes have no value for their <name node, so are not loaded
-        nodes = @node.xpath('./connection//metadata-record')
+        nodes = @node.xpath("./connection//metadata-record[@class='column']")
         nodes.each do |node|
           field = Twb::MetadataField.new(node)
           field.source = :db
@@ -234,34 +242,44 @@ module Twb
 
     def loadFieldUINames
       @fieldUINames = {}
-      columnNodes = @node.xpath('./column')
-      columnNodes.each do |cn|
-        name    = cn.attribute('name').text.gsub(/^\[|\]$/,'')
-        caption = cn.attribute('caption')
-        uiName  = caption.nil? ? name : caption.text
-        @fieldUINames[name]         = uiName
-        @fieldUINames[caption.text] = caption.text  unless caption.nil?    # in case of unintended usage: lookup by Caption name
+      metadataFields.each do |fld|
+        unless fld.localName.nil?
+          @fieldUINames[fld.localName] = fld.uiname
+          @fieldUINames[fld.uiname]    = fld.uiname
+        end
+      end
+      calculatedFields.each do |fld| 
+        @fieldUINames[fld.name]   = fld.uiname
+        @fieldUINames[fld.uiname] = fld.uiname
       end
-      mappedFields.each do |fname,fmap|
-        dbTable = fmap['table']
-        dbName  = fmap['dbName']
-        @fieldUINames[dbName] = fname  unless @fieldUINames.include?(dbName)
-        @fieldUINames[fname]  = fname  unless @fieldUINames.include?(fname)
+      localFields.each do |fld| 
+        @fieldUINames[fld.name]   = fld.uiname
+        @fieldUINames[fld.uiname] = fld.uiname
       end
     end
 
+    def tableFields
+      @tableFieldsMap.values
+    end
+
+    def dbFieldsMap
+      @tableFieldsMap
+    end
+
     def dbFields
-      return @mappedFields unless @mappedFields.nil?
-      loadTableFields
-      return @mappedFields
+      @tableFieldsMap.values
+    end
+
+    def mappedFieldsMap
+      loadTableFields if @tableFieldsMap.nil?
+      return @tableFieldsMap
     end
 
     def mappedFields
-      loadTableFields if @mappedFields.nil?
-      return @mappedFields
+      loadTableFields if @tableFieldsMap.nil?
+      return @tableFieldsMap.values
     end
 
-    # NOTE: Calculated Fields are mapped by their UI name
     def calculatedFieldsMap
       @calculatedFieldsMap ||= loadCalculatedFields
     end
@@ -296,48 +314,40 @@ module Twb
       @allFields = SortedSet.new
       dbf = dbFields
       @allFields << dbf.keys
+      @allFields << calculatedFieldNames
     end
 
     def has_field? fieldName
-      dbFields.has_key? fieldName
+      dbFieldsMap.has_key? fieldName
     end
 
     def fieldTable fieldName
-      loadTableFields if @mappedFields.nil?
-      tf = @mappedFields[fieldName]
-      return tf.nil? ? nil : tf['table']
+      loadTableFields if @tableFieldsMap.nil?
+      dbField = @tableFieldsMap[fieldName]
+      return dbField.nil? ? nil : dbField.dbtable
     end
 
     # fields are unique in the data source by UI name
     def loadTableFields
       # puts "DATA SOURCE FIELD TABLE LOAD"
-      @mappedFields = {}
+      @tableFieldsMap = {}
       fieldNodes = @node.xpath('./connection/cols/map')
       fieldNodes.each do |fn|
-        uiName = fn.attribute('key').text.gsub(/^\[|\]$/,'')
-        fldRef = fn.attribute('value').text.gsub(/^\[|\]$/,'')
-        parts  = fldRef.split('].[')
-        table  = parts[0]
-        dbName = parts[1]
-        @mappedFields[uiName] = {'table' => table, 'dbName' => dbName}
-        # puts "=== #{uiName} :: T=#{@mappedFields[uiName]['table']}  DBN=#{@mappedFields[uiName]['dbName']} "
+        dbField = Twb::DbField.new(@uiname, fn, :map)
+        @tableFieldsMap[dbField.uiname] = dbField
       end
       relTableNodes = @node.xpath('.//relation[@table]')
       relTableNodes.each do |relNode|
         table = relNode.attribute('name').text
-        cols = relNode.xpath('./columns/column')
+        cols  = relNode.xpath('./columns/column')
         cols.each do |col|
+          dbField = Twb::DbField.new(@uiname, col, :tableColumn, table)
           fldName = col.attribute('name')
-          @mappedFields[fldName.text] = {'table' => table, 'dbName' => @uiname} unless fldName.nil?
+          @tableFieldsMap[dbField.uiname] = dbField
         end
       end
     end
 
-    # =begin
-    #  <filter class='categorical' column='[enforcement_type]' filter-group='2'>
-    #    <groupfilter function='member' level='[enforcement_type]' member='&quot;towing&quot;' user:ui-domain='database' user:ui-enumeration='inclusive' user:ui-marker='enumerate' />
-    #  </filter>
-    # end
     def processFilters
       if @filters.nil?
         @filters = {}
@@ -360,70 +370,6 @@ module Twb
 
   end # class DataSource
 
-  # DataSource Utilities
-
-  # # Generates and returns a set of graph node-edge-node triplets.
-  # # The intention is to create a graph that can be standalone used as a subgraph by the function's caller.
-  # # The initial implementation only considers a linear list of node names as input, resulting in 
-  # # the creation of a single-path structure, e.g.
-  # #  [inNode] -> node1 -> node2 -> ... -> nodeN
-  # # this may manifest as a tree when there are siblings at any level, e.g.
-  # #  [inNode] -> node1 -> node11 -> ... -> nodeX
-  # #                    -> node22 -> ... -> nodeY
-  # #           -> node2 -> node21 -> ... -> nodeZ
-  # # Params:
-  # # +inNodes+::   the node(s) to which this function's generated graph is to be linked, may be nil:
-  # #   + , or multiple)
-  # # +nodesList+:: list of node types by name to be built and linked together, in the order named  
-  # def graphNodes nodesList
-  #   graph     = Twb::Util::Graphedges.new()
-  #   nodesList.each do |nName|
-  #   end
-  #   case @dsclass
-  #     when 'federated'
-  #       graph = processFederatedSource nodesList
-  #   end
-  #   return graph
-  # end
-
-  # def processFederatedSource nodesList
-  #   emit false, "       (federated)  #{dataSource.uiname}"
-  #   dsGNode     = Twb::Util::Graphnode.new(name: @uiname, id: @name, type: 'Data Connection')
-  #   graph       = Twb::Util::Graphedges.new(dsGNode)
-  #   edges       = []
-  #   dsNode      = dataSource.node
-  #   connections = dsNode.xpath('./connection/named-connections/named-connection/connection')
-  #   connections.each do |conn|
-  #     connClass  = conn.attribute('class').text
-  #     emit true, "CONN CLASS: #{connClass}"
-  #     # -- Generating Source Node
-  #     cgParams = @@cgNodeParams[connClass]
-  #     # emit true, "cgparams  : #{cgParams}"
-  #     cLabel       = buildConnGraphPart( conn, cgParams['label'])
-  #     cID          = buildConnGraphPart( conn, cgParams['id'])
-  #     cType        = cgParams['type']
-  #     # emit true, "   label  : #{cLabel}"
-  #     # emit true, "      id  : #{cID}"
-  #     # emit true, "    type  : #{cType}"
-  #     srcNode   = Twb::Util::Graphnode.new(name: cLabel,  id: cID,     type: 'Data Source')
-  #     graphEdge = Twb::Util::Graphedge.new(from: dsGNode, to: srcNode, relationship: 'is located at')
-  #     graph.edges << graphEdge
-  #   end
-  #   return graph
-  # end
-
-  # def buildConnGraphPart connNode, attributes
-  #   return connNode.attribute(attributes) if attributes.is_a? String
-  #   emit false, "ATTRIBUTES :: #{attributes}"
-  #   str = ''
-  #   attributes.each do |attName|
-  #     attrib = connNode.attribute(attName)
-  #     emit false, " -#{attName}\t-> #{attrib}"
-  #     str   += attrib.text unless attrib.nil?
-  #   end
-  #   return str
-  # end
-
 
   class JoinTablePair
     attr_reader :from, :to