codegraph 0.7.18 → 0.7.20

data/bin/codegraph

@@ -2,14 +2,16 @@
 # Which options are availabile ------------------------------------------------
 # Default settings
   $options = {
-    :files    => [],
+    :filelist => [],
     :mode     => nil,
-    :output   => "",
     :function => "",
     :depth    => nil,
     :adds     => [],
     :excludes => [],
-    :debug    => false
+    :cluster  => false,
+    :debug    => false,
+    :boxes   => false,
+    :rotate   => false
   }
 
 require "codegraph"
@@ -18,71 +20,54 @@ require "optparse"
 def parse(args)
   OptionParser.new do |opts|
     opts.banner = "Usage: codegraph [options]"
-    opts.on("-y", "--debug","Work in debuging mode") do |debug|
-      $options[:debug] = debug
+    opts.on("-d", "--debug","Work in debuging mode") do
+      $options[:debug] = true
     end
     opts.on( "-a","--add f1,f2,f3",Array,"Add function for scanning") do |adds|
       $options[:adds] = adds
     end
+    opts.on( "-x","--exclude f1,f2,f3",Array,"Exclude function from scanning") do |excludes|
+      $options[:excludes] = excludes
+    end
     opts.on("-f", "--function FUNCTION") do |func|
       $options[:function] = func
       $options[:mode] = 'single'
     end
-    opts.on( "-s","--show-body","Display function body") do |show|
-      $options[:mode] = 'show'
-    end
     opts.on("-u", "--upper-funx FUNCTION") do |func|
       $options[:function] = func
       $options[:mode] = 'upper'
     end
-    opts.on("-8", "--8-funx FUNCTION") do |func|
-      $options[:function] = func
-      $options[:mode] = 8
+    opts.on("-c","--with-files-cluster","Show filenames in graph") do
+      $options[:cluster] = true
     end
-    opts.on("-C", "--ctags-opts KIND",String) do |opts|
-      $options[:ctagsopts] = opts
+    opts.on("-r","--rotate","rotate graph 90deg [default:false]") do
+      $options[:rotate] = true
     end
-    opts.on("--match-before REGEXP",String) do |regexp|
-      $options[:matchBefore] = regexp
-    end
-    opts.on("--match-after REGEXP",String) do |regexp|
-      $options[:matchAfter] = regexp
+    opts.on("-b","--with-boxes","use boxes instead of ovals") do
+      $options[:boxes] = true
     end
+#   opts.on("-C", "--ctags-opts KIND",String) do |opts|
+#     $options[:ctagsopts] = opts
+#   end
+#   opts.on("--match-before REGEXP",String) do |regexp|
+#     $options[:matchBefore] = regexp
+#   end
+#   opts.on("--match-after REGEXP",String) do |regexp|
+#     $options[:matchAfter] = regexp
+#   end
     opts.on("-F", "--file-list file0,file1,file3", Array,"List of files (alternative \"file0 file1 file3\")") do |filelist|
       filelist.each do |filedesc|
         unless File.exist?(filedesc)
-          $options[:files] << Dir.glob(File.expand_path(filedesc))
+          $options[:filelist] << Dir.glob(File.expand_path(filedesc))
         else
-          $options[:files] = filelist
+          $options[:filelist] = filelist
         end
       end
-      $options[:files].flatten!
-    end
-    opts.on("-d", "--depth DEPTH","Set the maximum depth of the graph") do |depth|
-      $options[:depth] = depth
-    end
-    opts.on("-p", "--to-ps FILE", "Write Postscripts output file") do |ofile|
-      $options[:ofile] = ofile
-      $options[:output] = 'ps'
-    end
-    opts.on("-S", "--to-svg FILE", "Write Scalable Vector Graphic output file") do |ofile|
-      $options[:ofile] = ofile
-      $options[:output] = 'svg'
-    end
-    opts.on("-P", "--to-png FILE", "Write Portable Network Graphic output file") do |ofile|
-      $options[:ofile] = ofile
-      $options[:output] = 'png'
-    end
-    opts.on("-J", "--to-jpg FILE", "Write JPEG output file") do |ofile|
-      $options[:ofile] = ofile
-      $options[:output] = 'jpg'
-    end
-    opts.on("-D", "--to-dot FILE", "Write dot output file") do |ofile|
-      $options[:ofile] = ofile
-      $options[:output] = 'dot'
+      $options[:filelist].flatten!
     end
-    opts.on("-T", "--to-txt","Write to stdout") do 
-      $options[:output] = 'txt'
+    opts.on("-o", "--output FILE", "Write image output file (supported formats: ps,png,jpw,svg,..., see 'man dot')") do |ofile|
+      $options[:otype] = File.extname(ofile)[1..-1]
+      $options[:ofile] = ofile[0..(-$options[:otype].size-2)]
     end
     opts.on("-V", "--version","Print version") do 
       puts Codegraph::VERSION
@@ -94,52 +79,41 @@ def parse(args)
     end
   end.parse(args)
 
-  if $options[:files].flatten.empty?
+  if $options[:filelist].flatten.empty?
     warn 'Please use -F do define input files! Use -h for further help.'
     exit -1
   end
+  unless $options[:otype]
+    warn 'Please provide an output filename.'
+    exit -1
+  end
   $options
 end
 options = parse(ARGV)
 pp options if $options[:debug]
-#   ["--exclude",       "-x", GetoptLong::REQUIRED_ARGUMENT],
-#)
+
 # What kind of graph should be generated?
 case $options[:mode]
 when "upper"
-   g = UpperFunctionGraph.new($options[:function])
-when "single","show"
-   g = SingleFunctionGraph.new($options[:function])
-when 8
-   g = EightFunctionGraph.new($options[:function])
+  g = UpperFunctionGraph.new($options)
+when "single"
+  g = SingleFunctionGraph.new($options)
 else
-   g = FunctionGraph.new
+  g = FunctionGraph.new($options)
+  g.scan
 end
 
-# Set debug mode
-g.debug = $options[:debug]
-
-# Include additional functions?
-g.adds = $options[:adds]
-
-# Creates the Knodes/Edges of the graph
-g.fill($options[:files],$options[:excludes])
+g.rotate if $options[:rotate]
+g.node_attribs << g.box if $options[:boxes]
 
-# Remove edges 
-g.limit($options[:depth]) if $options[:depth]
-
-# What sort of output should be created?
-case $options[:output]
-when "ps", "svg", "png", "jpg"
-  g.to_type($options[:ofile],$options[:output])
-when "dot"
-  g.to_dot($options[:ofile])
-when "txt"
-  g.to_txt
-else 
-  if $options[:mode] == "show"
-    puts g.display_functionbody($options[:function])
-  else
-    g.display
-  end
+if $options[:cluster]
+  puts "Clustering wrt files"
+  fileGraph = FileGraph.new($options) if $options[:cluster]
+  fileGraph.rotate if $options[:rotate]
+  fileGraph.node_attribs << fileGraph.box  if $options[:boxes]
+  fileGraph.subgraph(g)
+  g = fileGraph
 end
+# What sort of output should be created?
+puts "Save graph to #{[$options[:ofile],$options[:otype]].join('.')}...." if $options[:debug]
+g.save($options[:ofile],$options[:otype])

data/gemspec

@@ -5,16 +5,14 @@ require 'rubygems'
 spec = Gem::Specification.new do |s|
   s.name              = "codegraph"
   s.version           = File.open("lib/codegraph.rb").readlines.grep(/VERSION/)[0].split('=').last.chomp.strip.tr("'",'')
-  s.date              = Time.new.to_s
+  s.date              = Time.new.strftime("%Y-%m-%d")
   s.platform          = Gem::Platform::RUBY
   s.bindir            = 'bin'
   s.files             = ["lib/codegraph.rb","bin/codegraph"] + ["gemspec","LICENSE"]
   s.executables       << 'codegraph'
-  s.add_dependency('rgl')
-  s.add_dependency('asciify')
+  s.add_dependency('graph')
   s.rubyforge_project = "codegraph"
   s.description       = "Display functional dependencies in source code (C, Fortran, PHP, Perl).\n"
-#    "Changes (#{s.version}):"
   s.summary           = "Display functional dependencies in source code (C, Fortran, PHP, Perl)"
   s.author            = "Ralf Mueller"
   s.email             = "stark.dreamdetective@gmail.com"

data/lib/codegraph.rb

@@ -1,312 +1,304 @@
-require 'pp'
-require 'rgl/adjacency'
-require 'rgl/dot'
-require 'rgl/rdot'
-require 'rgl/traversal'
-require 'thread'
+require 'jobqueue'
+require 'graph'
 require 'digest'
-require 'asciify'
 require 'json'
+require 'fileutils'
+require 'pp'
+
 
 module Codegraph
-  VERSION = '0.7.18'
+  VERSION = '0.7.20'
 end
 
-class FunctionGraph < RGL::DirectedAdjacencyGraph
-   attr_accessor :funx, :adds, :excludes, :debug
+class CodeParser
+  attr_reader   :funx,:files
+  attr_accessor :exclude
 
-   # Theses Parameters are used by interactive representation and for the file
-   # generation function to_dot and to_type. They can only be given for the
-   # whole graph, not for a singel node. This could be done by extending the
-   # dot.rb file of the Ruby Graph Library
-   Params = {'rankdir'     => 'LR',
-             'ranksep'     => '4.0',
-             'concentrate' => 'TRUE',
-             'label'       => '',
-             'fontsize'    => '12'}
+  @@ctagsOpts   = '--c-kinds=f --fortran-kinds=fsip --php-kinds=f --perl-kinds=f'
+  @@workDir     = ENV['HOME'] + '/.codegraph'
+  @@filesDBfile = @@workDir+'/filesDB.json'
+  @@filesDB     = File.exist?(@@filesDBfile) ? JSON.parse(File.open(@@filesDBfile).read) : Hash.new
+  @@filesCk     = @@filesDB.hash
+  @@lock        = Mutex.new
 
-   @@home        = ENV['HOME']
-   @@codehomedir = "#{@@home}/.codegraph"
-   @@filesDB     = @@codehomedir+'/filesDB.json'
-   @@funxDB      = @@codehomedir+'/funxDB.json'
+  # come class methods
+  def CodeParser.filesDB
+    @@filesDB
+  end
+  def CodeParser.filesCk
+    @@filesCk
+  end
+  #=============================================================================
 
-   @@matchBeforFuncName = $options[:matchBefor].nil? ? '[^A-z0-9_]( *)': $options[:matchBefor]
-   @@matchAfterFuncName = $options[:matchAfter].nil? ? '( *\(| |$)'   : $options[:matchAfter]
+  def initialize(debug=false,dir="#{ENV['HOME']}/.codegraph")
+    @dir     = dir
+    @debug   = debug
+    @funx    = {}
+    @files   = {}
+    @exclude = []
+  end
 
-   @@map = Asciify::Mapping.new(:default) 
-   
-   # Generate the codegraph storage directory
-   if not FileTest.directory?(@@codehomedir) 
-      system("mkdir #{@@codehomedir}")
-   end
-
-   def initialize
-      super
-      @debug   = false
-      # the following attribute will hold the functionnames and their bodies
-      @funx    = Hash.new
-      @lock    = Mutex.new
-      @filesDB = File.exist?(@@filesDB) ? JSON.parse(File.open(@@filesDB).read) : Hash.new
-      @filesCk = @db.hash
-      @funxDB  = File.exist?(@@funxDB) ? JSON.parse(File.open(@@funxDB).read) : Hash.new
-      @funxCk  = @funxDB.hash
-
-      @adds, @excludes = [],[]
-   end
-   
-   # Generates the necessary files:
-   # 1. One for the whole source code
-   # 2. One for functions inside the file 1
-   #  and fill the @funx hash
-   def genFiles(graph, filelist, exclude=[])
-      threads = []
-
-      filelist.each {|file|
-        threads << Thread.new(file, @@codehomedir) {|file,codehomedir|
-          funxFile   = "funxnames"
-          ctagsKinds = $options[:ctagsopts].nil? ? '--c-kinds=f --fortran-kinds=fsip --php-kinds=f --perl-kinds=f' : $options[:ctagsopts]
+  def read(*filelist)
+    jobqueue = JobQueue.new
 
+    filelist.each {|file|
+      jobqueue.push {
+        unless File.exist?(file)
+          warn "Cannot find file #{file}"
+          return
+        else
           puts "Processing #{file} ..." if @debug
-          checksum = Digest::SHA256.file(file).hexdigest
-          if @filesDB.has_key?(checksum)
-            code,funxLocations = @filesDB[checksum]
-          else
-            basefile = File.basename(file)
-            tempfile = "_" + basefile
-            case File.extname(file)
-            when '.c','.h' 
-              cppCommand = "cpp -w -fpreprocessed -E  -fdirectives-only #{file}  -o #{codehomedir}/#{tempfile} 2>/dev/null"
-              cppCommand = "cpp -fpreprocessed #{file}  -o #{codehomedir}/#{tempfile} 2>/dev/null"
-              grep       = "grep -v -e '^$' #{codehomedir}/#{tempfile} | grep -v -e '^#' > #{codehomedir}/#{basefile}"
-            when '.f','.f77','.f90','.f95'
-              cppCommand = "cp #{file} #{codehomedir}/#{tempfile}"
-              grep       = "grep -v -e '^$' #{codehomedir}/#{tempfile} | grep -v -e '^ *!' > #{codehomedir}/#{basefile}"
-            else
-              cppCommand = "cp #{file} #{codehomedir}/#{tempfile}"
-              grep       = "grep -v -e '^$' #{codehomedir}/#{tempfile} | grep -v -e '^#' > #{codehomedir}/#{basefile}"
-            end
-            gen4ctags  = "ctags -x #{ctagsKinds}  #{codehomedir}/#{basefile} | sort -n -k 3"
-            command    = [cppCommand,grep].join(";")
+        end
 
-            puts gen4ctags if @debug
-            puts command if @debug
-            system(command)
+        checksum = Digest::SHA256.file(file).hexdigest
+        if @@filesDB.has_key?(checksum) and @@filesDB.has_key?(file)
+          code,funxLocations = @@filesDB[checksum]
+          @files[file]       = @@filesDB[file]
+        else
+          basefile = File.basename(file)
+          tempfile = "_" + basefile
+          case File.extname(file)
+          when '.c','.h'
+            cppCommand = "cpp -w -fpreprocessed -E  -fdirectives-only #{file}  -o #{@dir}/#{tempfile} 2>/dev/null"
+            cppCommand = "cpp -fpreprocessed #{file}  -o #{@dir}/#{tempfile} 2>/dev/null"
+            grep       = "grep -v -e '^$' #{@dir}/#{tempfile} | grep -v -e '^#' > #{@dir}/#{basefile}"
+          when '.f','.f77','.f90','.f95'
+            cppCommand = "cp #{file} #{@dir}/#{tempfile}"
+            grep       = "grep -v -e '^$' #{@dir}/#{tempfile} | grep -v -e '^ *!' > #{@dir}/#{basefile}"
+          else
+            cppCommand = "cp #{file} #{@dir}/#{tempfile}"
+            grep       = "grep -v -e '^$' #{@dir}/#{tempfile} | grep -v -e '^#' > #{@dir}/#{basefile}"
+          end
+          gen4ctags  = "ctags -x #{@@ctagsOpts}  #{@dir}/#{basefile} | sort -n -k 3"
+          command    = [cppCommand,grep].join(";")
 
-            code          = open(codehomedir+'/'+ File.basename(file)).readlines
-            funxLocations = IO.popen(gen4ctags).readlines.map {|l| l.split[0,4]}
-            @lock.synchronize { @filesDB[checksum] = [code,funxLocations] }
+          puts gen4ctags if @debug
+          puts command if @debug
+          system(command)
 
-            # cleanup
-            FileUtils.rm("#{codehomedir}/#{tempfile}")
-            FileUtils.rm("#{codehomedir}/#{basefile}")
-          end
+          code          = open(@dir+'/'+ File.basename(file)).readlines
+          funxLocations = IO.popen(gen4ctags).readlines.map {|l| l.split[0,4]}
+          @@lock.synchronize { 
+            @@filesDB[checksum] = [code,funxLocations]
+            @@filesDB[file]     = funxLocations.map {|v| v[0]}
+            @files[file]        = @@filesDB[file]
+          }
 
-          funxLocations.each_with_index {|ary,i|
-            name, kind, line, file = ary
-            puts name if @debug
-            line           = line.to_i
-            startLineIndex = line - 1
-            endLineIndex   = (i+1 < funxLocations.size) ? funxLocations[i+1][2].to_i - 2 : -1
-            body = code[startLineIndex..endLineIndex].join
-            @lock.synchronize {
-              @funx.store(name,body)
-            }
+          # cleanup
+          FileUtils.rm("#{@dir}/#{tempfile}") unless @debug
+          FileUtils.rm("#{@dir}/#{basefile}") unless @debug
+        end
+        funxLocations.each_with_index {|ary,i|
+          name, kind, line, file = ary
+          next if @exclude.include?(name)
+          puts name if @debug
+          line           = line.to_i
+          startLineIndex = line - 1
+          endLineIndex   = (i+1 < funxLocations.size) ? funxLocations[i+1][2].to_i - 2 : -1
+          body = code[startLineIndex..endLineIndex].join
+          @@lock.synchronize {
+            @funx.store(name,body)
           }
         }
       }
-      threads.each {|t| t.join}
+    }
+    jobqueue.run
+
+    updateFilesDB
+  end
+  def updateFilesDB
+     File.open(@@filesDBfile,"w") {|f| f << JSON.generate(@@filesDB)} unless @@filesCk == @@filesDB.hash
+  end
+  private :updateFilesDB
+end
+
+# needed for svg output
+class Graph
+  def empty?
+    edges.empty?
+  end
+end
 
-      # update the code database in case of anything new
-      updateFilesDB
+class FunctionGraph < Graph
+  attr_accessor :funx, :adds, :excludes, :debug
 
-      if @funx.empty?
-         warn "no functions found"
-         exit -1
-      end
-   end
+  # internal database for former scans
+  @@workDir    = ENV['HOME'] + '/.codegraph'
+  @@funxDBfile = @@workDir+'/funxDB.json'
+  @@funxDB     = File.exist?(@@funxDBfile) ? JSON.parse(File.open(@@funxDBfile).read) : Hash.new
+  @@lock       = Mutex.new
+
+  def initialize(config)
+    super(self.class.to_s)
+    @config  = config 
+
+    @debug   = @config[:debug]
+
+    @@matchBeforFuncName = @config[:matchBefor].nil? ? '[^A-z0-9_]\s*': @config[:matchBefor]
+    @@matchAfterFuncName = @config[:matchAfter].nil? ? '( *\(| |$)'   : @config[:matchAfter]
+
+    @adds     = @config[:adds] || []
+    @excludes = @config[:excludes] || []
+
+    @parser   = CodeParser.new
+    @parser.read(*@config[:filelist])
+    @funx     = @parser.funx
+  end
    
-   # fill the graph with all functions found in <filelist> 
-   # while all functions from <exclude> aren't recognized
-   def fill(filelist,exclude=[])
-      # generate the necessary files and fill @funx
-      genFiles(self,filelist,exclude)
-
-      # scan functions for the function names
-      names = @funx.keys
-      @funx.each_pair {|name,body|
-#        threads=[];threads << Thread.new(name,body,names) {|name,body,names|
-          puts "Add func: #{name}" if @debug
-          # Check if this body is in the funx DB
-          bodyCk = Digest::SHA256.hexdigest(body)
-          if @funxDB.has_key?(bodyCk) and @funxDB[name] == body
-            edges = @funxDB[bodyCk]
-            edges.each {|edge| add_edge(*edge)}
-          else
-            edges = []
-            add_vertex(name)
-            (names - [name] + @adds).each { |func|
-              puts name if @debug
-              if/#@@matchBeforFuncName#{func}#@@matchAfterFuncName/.match(body)
-                edge = ["#{name}","#{func}"]
-                add_edge(*edge)
-                edges << edge
-              end
-            }
-#            @lock.synchronize { 
-              @funxDB[bodyCk] = edges
-              @funxDB[name]   = body
-#            }
-          end
-#        }
+  def scan
+    jobqueue = JobQueue.new
+    # scan functions fo all other function names
+    names = @parser.funx.keys + @adds - @excludes
+    @parser.funx.each_pair {|name,body|
+      next unless names.include?(name)
+      jobqueue.push {
+        puts "Add func: #{name}" if @debug
+        # Check if this body is in the funx DB
+        bodyCk = Digest::SHA256.hexdigest(body)
+        if @@funxDB.has_key?(bodyCk) and @@funxDB[name] == body
+          edges = @@funxDB[bodyCk]
+          edges.each {|edge| self.edge(*edge)}
+        else
+          edges = []
+          self.node(name)
+          (names - [name]).each { |func|
+            if/#@@matchBeforFuncName#{Regexp.escape(func)}#@@matchAfterFuncName/.match(body)
+              edge = ["#{name}","#{func}"]
+              self.edge(*edge)
+              edges << edge
+            end
+          }
+          @@lock.synchronize {
+            @@funxDB[bodyCk] = edges
+            @@funxDB[name]   = body
+          }
+        end
       }
-#     threads.each {|t| t.join}
-     updateFunxDB
-   end
-
-   def limit(depth)
-     dv = RGL::DFSVisitor.new(self)
-     dv.attach_distance_map
-     self.depth_first_search(dv) {|u|
-       self.remove_vertex(u) if dv.distance_to_root(u) > depth
-     }
-   end
-
-  def display_functionbody(name)
-    @funx[name]
+    }
+    jobqueue.run
+
+    updateFunxDB
   end
-   # Creates a simple dot file according to the above <Params>. 
-   # Parameters for the nodes are not supported by rgl.
-   def to_dot(filename)
-      File.open(filename,"w") {|f|
-         print_dotted_on(Params,f)
-      }
-   end
 
-   # Generates pairs of "func_A -> func_B" to stdout
-   def to_txt
-      each_edge do |left,right|
-         print left,' -> ',right,"\n"
-      end
-   end
+  def showBody(name)
+    @funx[name]
+  end
 
-   # This function generates a file of the given type using the dot utility.
-   # Supported Types are PS, PNG, JPG, DOT and SVG.
-   def to_type(filename,type)
-      if File.exist?(filename) 
-         system("rm #{filename}")
-      end
-      if File.exist?(filename+"."+type) 
-         system("rm #{filename}."+type)
-      end
-      to_dot(filename+".dot")
-      system("dot -T#{type} -o #{filename} -Nshape=box #{filename}.dot")
-      system("rm #{filename}.dot")
-   end
-
-   # Display the graph with an interactive viewer
-   def display
-      dotty(Params)
-      system("rm graph.dot") if File.exist?("graph.dot")
-   end
-
-   def updateFilesDB
-      File.open(@@filesDB,"w") {|f| f << JSON.generate(@filesDB)} unless @filesCk == @filesDB.hash
-   end
-   def updateFunxDB
-      File.open(@@funxDB,"w") {|f| f << JSON.generate(@funxDB)} unless @funxCk == @filesDB.hash
-   end
-   private :genFiles,:updateFilesDB,:updateFunxDB
+  def updateFunxDB
+    File.open(@@funxDBfile,"w") {|f| f << JSON.generate(@@funxDB)}# unless @funxCk == @parser.filesCk
+  end
+  private :updateFunxDB
 end
 
 class SingleFunctionGraph < FunctionGraph
-   attr_accessor  :func
-
-   # Constructor, which creates an empty graph for the rootfunction <func>
-   def initialize(func)
-      # Holds the func'n names, that are allready scanned
-      @scannednames = []
-      # Root func
-      @func = func
-      super()
-   end
-
-   # Works like the one from FunctionGraph except, that it calls 'scan' 
-   # for the recursive descent throug all functions given in <filelist> - exclude
-   def fill(filelist,exclude=[])
-      genFiles(self,filelist,exclude)
-      scan(self, func)
-   end
-
-   # For the given root function f, scan walks through the graph, and finds any
-   # other function, that calls f
-   def scan(graph,f)
-      if (@scannednames.include?(f)) 
+  attr_accessor  :func
+
+  # Constructor, which creates an empty graph for the rootfunction <func>
+  def initialize(config)
+    super(config)
+    # Holds the func'n names, that are allready scanned
+    @scannednames = []
+    # Root func
+    @func = @config[:function]
+    scan(self,@func)
+  end
+
+  # For the given root function f, scan walks through the graph, and finds any
+  # other function, that calls f
+  def scan(graph,f)
+    puts "Scanning #{f} ..." if @config[:debug]
+    if (@scannednames.include?(f)) 
+      return
+    else
+      names = graph.funx.keys + @adds - @excludes
+      unless names.include?(f)
+        warn "Function #{func} not found."
+        return
+      end
+      @scannednames << f
+      body   = graph.funx[f]
+      bodyCk = Digest::SHA256.hexdigest(body)
+      if @@funxDB.has_key?(bodyCk) and @@funxDB[f] == body
+        edges = @@funxDB[bodyCk]
+        edges.each {|edge| graph.edge(*edge)}
+        (edges.flatten.uniq-[f]).each {|g| scan(graph,g)}
       else
-         names = graph.funx.keys
-         if not names.include?(func)
-            warn "Function #{func} not found."
-            exit -1
-         end
-         @scannednames << f
-         body = graph.funx[f]
-         # scan for any other function in the body of f
-         (names - [f] + @adds).each {|g|
-            if /#@@matchBeforFuncName#{g}#@@matchAfterFuncName/.match(body) 
-               graph.add_edge(f,g)
-               # go downstairs for all functions from the scanned files
-               scan(graph,g) if names.include?(g)
-            end
-         }
+        edges = []
+        # scan for any other function in the body of f
+        (names - [f]).each {|g|
+          if /#@@matchBeforFuncName#{Regexp.escape(g)}#@@matchAfterFuncName/.match(body) 
+            graph.edge(f,g)
+            edges << [f,g]
+            # go downstairs for all functions from the scanned files
+            scan(graph,g) if names.include?(g)
+          end
+        }
+        #@@lock.synchronize {
+          @@funxDB[bodyCk] = edges
+          @@funxDB[f]      = body
+        #}
       end
-   end
-   private :scan
+    end
+  end
+  private :scan
 end
 
 class UpperFunctionGraph < SingleFunctionGraph
-  
-   # scanning upwards unlike SingleFunctionGraph.scan
-   def scan(graph,func)
-      if @scannednames.include?(func) 
-      else
-         if not (graph.funx.keys + @adds).include?(func)
-            warn "Function '#{func}' not found. If this is an internal function, " +
-                 "please try again with the '-w' option to include the internal " +
-                 "funx before scanning."
-            exit -1
-         end
-         @scannednames << func
-         graph.funx.each_pair {|g,gbody|
-            # dont scan a function for itself
-            next if g == func
-            puts g if @debug
-            puts gbody if @debug
-            if/#@@matchBeforFuncName#{func}#@@matchAfterFuncName/.match(Asciify.new(@@map).convert(gbody))
-               graph.add_edge(g,func)
-               scan(graph,g)
-            end
-         }
+
+  # scanning upwards unlike SingleFunctionGraph.scan
+  def scan(graph,func)
+    if @scannednames.include?(func) 
+    else
+      names = graph.funx.keys + @adds - @excludes
+      unless names.include?(func)
+        warn "Function '#{func}' not found"
+        exit -1
       end
-   end
-   private :scan
+      @scannednames << func
+      graph.funx.each_pair {|g,gbody|
+        # dont scan a function for itself
+        next if g == func
+        puts g if @debug
+        if/#@@matchBeforFuncName#{Regexp.escape(func)}#@@matchAfterFuncName/.match(gbody)
+          graph.edge(g,func)
+          scan(graph,g)
+        end
+      }
+    end
+  end
+  private :scan
 end
 
 class EightFunctionGraph < FunctionGraph
-  def initialize(func)
-    super()
-    @func = func
+  def initialize(config)
+    super(config)
+    @config = config
+    gDown = SingleFunctionGraph.new(@config)
+    gUp   = UpperFunctionGraph.new(@config)
   end
-  def fill(*args)
-    g_down = SingleFunctionGraph.new(@func)
-    g_down.fill(*args)
+end
 
-    g_up   = UpperFunctionGraph.new(@func)
-    g_up.fill(*args)
+class FileGraph < Graph
+  attr_reader :funx,:files
+  def initialize(config)
+    super(self.class.to_s)
+    @config      = config
+    @debug       = @config[:debug]
+    @parser      = CodeParser.new
+    @parser.read(*@config[:filelist])
+    @funx,@files = @parser.funx, @parser.files
 
-    g_down.each_edge do |u,v|
-      self.add_edge(u,v)
-    end
-    g_up.each_edge do |u,v|
-      self.add_edge(u,v)
-    end
+    scan
+  end
+
+  def scan
+    leaf_node = white + filled
+    @files.each {|file,myfunx|
+      subgraph "cluster_#{rand(1000)}_#{file}" do
+        label file
+        graph_attribs << blue << filled << lightgray
+        myfunx.each {|func| node(func)}
+      end
+    }
   end
 end

metadata

@@ -1,94 +1,62 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: codegraph
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 7
-  - 18
-  version: 0.7.18
+version: !ruby/object:Gem::Version
+  version: 0.7.20
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Ralf Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-11-01 09:18:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rgl
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2012-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graph
+  requirement: &8260220 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: asciify
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id002
-description: |
-  Display functional dependencies in source code (C, Fortran, PHP, Perl).
+  version_requirements: *8260220
+description: ! 'Display functional dependencies in source code (C, Fortran, PHP, Perl).
 
+'
 email: stark.dreamdetective@gmail.com
-executables: 
+executables:
 - codegraph
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/codegraph.rb
 - bin/codegraph
 - gemspec
 - LICENSE
-has_rdoc: true
 homepage: http://codegraph.rubyforge.org
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: codegraph
-rubygems_version: 1.3.7
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Display functional dependencies in source code (C, Fortran, PHP, Perl)
 test_files: []
-