codegraph 0.7.1

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2009, Ralf Mueller (stark.dreamdetective@googlemail.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * The names of its contributors may not be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/bin/codegraph

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+require "codegraph"
+require "getoptlong"
+
+def show_usage
+puts <<-END
+Usage: #{__FILE__}: 
+                    --help, -h   guess what
+                    
+                    --file-list, -F "<list>"
+                                 fill the graph with every function, 
+                                 that has a definiton inside the given files
+                    
+                    --function, -f "<funcname>"
+                                 take the given func as the root knode
+
+                    --show-body, -s "<funcname>"
+                                 display the function code in the terminal
+                                 
+                    --upper-funx, -u "<funcname>"
+                                 scan for all funx, which depends directly or 
+                                 indirectly on <funcname>
+                                 
+                    --8-funx, -8 "<funcname>"
+                                 scan for all funx, which depends (in)directly
+                                 <funcname> AND which call <funcname> 
+                                 (in)directly
+                                 
+                    --exclude, -x "<list>"
+                                 exclude a list of functions from the graph
+                                 
+                    --depth, -d <integer>
+                                 Set maximal Graph depth
+                                 
+                    --to-ps, -p <filename>
+                                 create a postscript file from the graph
+                                 
+                    --to-svg, -S <filename>
+                                 create a SVG file from the graph
+                                 
+                    --to-png, -P <filename>
+                                 create a PNG file from the graph
+                                 
+                    --to-jpg, -J <filename>
+                                 create a JPG file from the graph
+                                 
+                    --to-dot, -D <filename>
+                                 creates a <filename>.dot-file
+                                 
+                    --to-txt, -T
+                                 writes the relations to stdout
+END
+end
+# Which options are availabile ------------------------------------------------
+options = GetoptLong.new(
+   ["--help",          "-h", GetoptLong::NO_ARGUMENT],
+#   ["--local",         "-l", GetoptLong::NO_ARGUMENT],
+#   ["--source",        "-s", GetoptLong::NO_ARGUMENT],
+#   ["--with-internal", "-w", GetoptLong::NO_ARGUMENT],
+   ["--function",      "-f", GetoptLong::REQUIRED_ARGUMENT],
+   ["--show-body",     "-s", GetoptLong::REQUIRED_ARGUMENT],
+   ["--upper-funx",    "-u", GetoptLong::REQUIRED_ARGUMENT],
+   ["--8-funx",        "-8", GetoptLong::REQUIRED_ARGUMENT],
+   ["--file-list",     "-F", GetoptLong::REQUIRED_ARGUMENT],
+   ["--depth",         "-d", GetoptLong::REQUIRED_ARGUMENT],
+   ["--to-ps",         "-p", GetoptLong::REQUIRED_ARGUMENT],
+   ["--to-svg",        "-S", GetoptLong::REQUIRED_ARGUMENT],
+   ["--to-png",        "-P", GetoptLong::REQUIRED_ARGUMENT],
+   ["--to-jpg",        "-J", GetoptLong::REQUIRED_ARGUMENT],
+   ["--to-dot",        "-D", GetoptLong::REQUIRED_ARGUMENT],
+   ["--to-txt",        "-T", GetoptLong::NO_ARGUMENT],
+   ["--exclude",       "-x", GetoptLong::REQUIRED_ARGUMENT],
+)
+options.ordering = GetoptLong::RETURN_IN_ORDER
+# Default values --------------------------------------------------------------
+filelist = ""
+mode     = "multiple"
+output   = ""
+internal = false
+filename = ""
+dotfile  = ""
+function = ""
+depth = nil
+exclude  = Array.new
+files    = Array.new
+# option parsing --------------------------------------------------------------
+options.each do |opt, arg|
+   case opt
+      when "--file-list"
+         filelist = arg
+         files = Dir.glob(filelist.split(' '))
+      when "--function"
+         mode     = "single"
+         function = arg
+      when "--show-body"
+         mode     = "show"
+         function = arg
+      when "--upper-funx"
+         mode     = "upper"
+         function = arg
+      when "--8-funx"
+         mode     = 8
+         function = arg
+      when "--depth"
+         depth = arg.to_i
+      when "--to-ps"
+         output   = "ps"
+         filename = arg
+      when "--to-svg"
+         output   = "svg"
+         filename = arg
+      when "--to-png"
+         output   = "png"
+         filename = arg
+      when "--to-jpg"
+         output   = "jpg"
+         filename = arg
+      when "--to-dot"
+         output   = "dot"
+         filename = arg
+      when "--to-txt"
+         output = "txt"
+      when "--exclude"
+         exclude = arg.split(/ /)
+      else
+         show_usage
+         exit
+   end
+end
+options.terminate
+# script controlling ----------------------------------------------------------
+# Is the filelist correct?
+if files.size == 0
+  puts 'Please use --file-list "<list>"'
+  show_usage
+  exit
+end
+
+# What kind of graph should be generated?
+case mode
+   when "upper"
+      g = UpperFunctionGraph.new(function)
+   when "single","show"
+      g = SingleFunctionGraph.new(function)
+   when 8
+      g = EightFunctionGraph.new(function)
+   else
+      g = FunctionGraph.new
+end
+
+# Include the internal functions of the language?
+g.internal = internal
+
+# Creates the Knodes/Edges of the graph
+g.fill(files,exclude)
+
+# Remove edges 
+g.limit(depth) if depth
+
+# What sort of output should be created?
+case output
+   when "ps", "svg", "png", "jpg"
+      g.to_type(filename,output)
+   when "dot"
+      g.to_dot(filename)
+   when "txt"
+      g.to_txt
+   else 
+     if mode == "show"
+       puts g.display_functionbody(function)
+     else
+       g.display
+     end
+   end

data/gemspec

@@ -0,0 +1,21 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |s|
+  s.name              = "codegraph"
+  s.version           = "0.7.1"
+  s.date              = "2010-11-01"
+  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.rubyforge_project = "codegraph"
+  s.description       = "Display functional dependencies in source code (C, Fortran, PHP, Perl)."
+  s.summary           = "Display functional dependencies in source code (C, Fortran, PHP, Perl)"
+  s.author            = "Ralf Mueller"
+  s.email             = "stark.dreamdetective@gmail.com"
+  s.homepage          = "http://codegraph.rubyforge.org"
+  s.has_rdoc          = true
+end
+
+# vim:ft=ruby

data/lib/codegraph.rb

@@ -0,0 +1,280 @@
+require 'rubygems'
+require 'rgl/adjacency'
+require 'rgl/dot'
+require 'rgl/rdot'
+require 'rgl/traversal'
+
+class FunctionGraph < RGL::DirectedAdjacencyGraph
+   attr_accessor :funx, :internal
+
+   # 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'}
+
+   # Hash of supported langs and the ctags marker for functions             
+   Types = {"php"  => "f",
+            "perl" => "s",
+            "c"   => "f",
+            "f"   => "fs",
+            "sh"   => "f"}
+
+   # Hash of how ctags calls function for each lang
+   Funx  = {"php"     => "function",
+            "perl"    => "subroutine",
+            "c"       => "function",
+            "f" => "subroutine",
+            "sh"      => "function"}
+
+   @@home               = `echo $HOME`.chomp
+   @@codehomedir        = "#{@@home}/.codegraph"
+   @@internal_funx      = []
+   @@matchBeforFuncName = '[^A-z0-9_]'
+   @@matchAfterFuncName = '\('
+   
+   # Generate the codegraph storage directory
+   if not FileTest.directory?(@@codehomedir) 
+      system("mkdir #{@@codehomedir}")
+   end
+
+   def initialize
+      super
+      # the following attribute will hold the functionnames and their bodies
+      @funx = Hash.new
+
+      # Should the internal functions be displayed?
+      @internal = false
+
+   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=[])
+      names, kinds, lines, files = [],[],[],[]
+
+      funxFile   = "funxnames"
+      ctagsKinds='--c-kinds=f --fortran-kinds=fs --php-kinds=f --perl-kinds=f'
+      filelist.each {|file|
+        puts "Processing #{file} ..."
+        basefile   = File.basename(file)
+        temfile    = "_" + basefile
+        case File.extname(file)
+        when '.c','.h' 
+          cppCommand = "cpp -w -fpreprocessed -E  -fdirectives-only #{file}  -o #{@@codehomedir}/#{temfile}"
+          grep       = "grep -v -e '^$' #{temfile} | grep -v -e '^#' > #{basefile}"
+        when '.f','.f77','.f90','.f95'
+          cppCommand = "cp #{file} #{@@codehomedir}/#{temfile}"
+          grep       = "grep -v -e '^$' #{temfile} | grep -v -e '^ *!' > #{basefile}"
+        else
+          cppCommand = "cp #{file} #{@@codehomedir}/#{temfile}"
+          grep       = "grep -v -e '^$' #{temfile} | grep -v -e '^#' > #{basefile}"
+        end
+        cd         = "cd #{@@codehomedir}"
+        gen4ctags  = "ctags -x #{ctagsKinds} #{basefile} | sort -n -k 3 > " + funxFile
+        command    = [cppCommand,cd,grep,gen4ctags].join(";")
+
+        puts command
+        system(command)
+
+        open(@@codehomedir+'/'+funxFile).readlines.each {|line|
+          name, kind, lineno, file = line.split[0,4]
+          names << name
+          kinds << kind
+          lines << lineno.to_i
+          files << file
+        }
+      }
+
+      unless File.size?(@@codehomedir+'/'+funxFile)
+         puts "no functions found"
+         exit
+      end
+
+      meta = [names, kinds, lines, files]
+
+      # read the source once and save the function bodies as values 
+      # of the function names
+
+      metasize = meta[2].size
+      lastfile,code = nil,nil
+      meta.transpose.each_with_index {|ary,i|
+        name, kind, line, file = ary
+        
+        if file != lastfile
+          code = open(@@codehomedir+'/'+ File.basename(file)).readlines
+          codeLength = code.length
+        end
+        startLineIndex = meta[2][i]-1
+        endLineIndex   = (i+1 < metasize) ? meta[2][i+1] - 2 : -1
+        # code-Index starts with 0 vs. line numbbers in (meta|m).lines start with 1
+        body = code[startLineIndex..endLineIndex].join
+
+        @funx.store(name,body)
+        lastfile = file
+      }
+   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|
+            add_vertex(name)
+            (names - [name] + @@internal_funx).each { |func|
+              add_edge("#{name}","#{func}") if /#@@matchBeforFuncName#{func}/.match(body)
+            }
+      }
+   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]
+  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
+
+   # 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
+   private :genFiles
+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)) 
+      else
+         names = graph.funx.keys
+         if not names.include?(func)
+            puts "Function #{func} not found."
+            exit
+         end
+         @scannednames << f
+         body = graph.funx[f]
+         # scan for any other function in the body of f
+         (names - [f] + @@internal_funx).each {|g|
+            if /#@@matchBeforFuncName#{g}#@@matchAfterFuncName/.match(body) 
+               graph.add_edge(f,g)
+               # unless its not an internal function, go downstairs
+               scan(graph,g) if names.include?(g)
+            end
+         }
+      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 + @@internal_funx).include?(func)
+            puts "Function '#{func}' not found. If this is an internal function, " +
+                 "please try again with the '-w' option to include the internal " +
+                 "funx before scanning."
+            #system("rm ~/.codegraph/all.#{ng} ~/.codegraph/code-names")
+            exit
+         end
+         @scannednames << func
+         graph.funx.each_pair {|g,gbody|
+            # dont scan a function for itself
+            next if g == func
+
+            if/#@@matchBeforFuncName#{func}#@@matchAfterFuncName/.match(gbody)
+               graph.add_edge(g,func)
+               scan(graph,g)
+            end
+         }
+      end
+   end
+   private :scan
+end
+
+class EightFunctionGraph < FunctionGraph
+  def initialize(func)
+    super()
+    @func = func
+  end
+  def fill(*args)
+    g_down = SingleFunctionGraph.new(@func)
+    g_down.fill(*args)
+
+    g_up   = UpperFunctionGraph.new(@func)
+    g_up.fill(*args)
+
+    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
+  end
+end
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: codegraph
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  - 1
+  version: 0.7.1
+platform: ruby
+authors: 
+- Ralf Mueller
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-01 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rgl
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Display functional dependencies in source code (C, Fortran, PHP, Perl).
+email: stark.dreamdetective@gmail.com
+executables: 
+- codegraph
+extensions: []
+
+extra_rdoc_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: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: codegraph
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Display functional dependencies in source code (C, Fortran, PHP, Perl)
+test_files: []
+