codegraph 0.7.8 → 0.7.11

data/bin/codegraph

@@ -1,175 +1,135 @@
 #!/usr/bin/env ruby
 require "codegraph"
-require "getoptlong"
+require "optparse"
 
-def show_usage
-puts <<-END
-Usage: codegraph    --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
+# Which options are availabile ------------------------------------------------
+# Default settings
+  $options = {
+    :files    => [],
+    :mode     => nil,
+    :output   => "",
+    :function => "",
+    :depth    => nil,
+    :adds     => [],
+    :excludes => [],
+    :debug    => false
+  }
+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
+    end
+    opts.on( "-a","--add f1,f2,f3",Array,"Add function for scanning") do |adds|
+      $options[:adds] = adds
+    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
+    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))
+        else
+          $options[:files] = 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'
+    end
+    opts.on("-T", "--to-txt","Write to stdout") do 
+      $options[:output] = 'txt'
+    end
+    opts.on("-V", "--version","Print version") do 
+      puts Codegraph::VERSION
+      exit
+    end
+    opts.on_tail("-h", "--help","Showthis message") do
+      puts opts
+      exit
+    end
+  end.parse(args)
 
-                    --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
-                                 
-                    --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
+  if $options[:files].flatten.empty?
+    warn 'Please use -F do define input files! Use -h for further help.'
+    exit
+  end
+  $options
 end
-# Which options are availabile ------------------------------------------------
-options = GetoptLong.new(
-   ["--help",          "-h", GetoptLong::NO_ARGUMENT],
-   ["--debug",         "-y", GetoptLong::NO_ARGUMENT],
-#   ["--add",           "-a", GetoptLong::REQUIRED_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]
+options = parse(ARGV)
+pp options if $options[:debug]
 #   ["--exclude",       "-x", GetoptLong::REQUIRED_ARGUMENT],
-)
-options.ordering = GetoptLong::RETURN_IN_ORDER
-# Default values --------------------------------------------------------------
-filelist = ""
-mode     = "multiple"
-output   = ""
-internal = false
-filename = ""
-dotfile  = ""
-function = ""
-depth    = nil
-adds     = Array.new
-excludes = Array.new
-files    = Array.new
-debug    = false
-# 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 "--add"
-         adds = arg.split(/ /)
-      when "--exclude"
-         excludes = arg.split(/ /)
-      when "--debug"
-        debug = true
-      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
+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])
+else
+   g = FunctionGraph.new
 end
 
 # Set debug mode
-g.debug = debug
+g.debug = $options[:debug]
 
-# Include the internal functions of the language?
-g.adds = adds
+# Include additional functions?
+g.adds = $options[:adds]
 
 # Creates the Knodes/Edges of the graph
-g.fill(files,excludes)
+g.fill($options[:files],$options[:excludes])
 
 # Remove edges 
-g.limit(depth) if depth
+g.limit($options[:depth]) if $options[: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
+case $options[:output]
+when "ps", "svg", "png", "jpg"
+  g.to_type($options[:filename],$options[:output])
+when "dot"
+  g.to_dot($options[:filename])
+when "txt"
+  g.to_txt
+else 
+  if $options[:mode] == "show"
+    puts g.display_functionbody($options[:function])
+  else
+    g.display
+  end
+end

data/gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 spec = Gem::Specification.new do |s|
   s.name              = "codegraph"
-  s.version           = "0.7.8"
+  s.version           = "0.7.11"
   s.date              = Time.new.to_s
   s.platform          = Gem::Platform::RUBY
   s.bindir            = 'bin'

data/lib/codegraph.rb

@@ -6,6 +6,10 @@ require 'rgl/traversal'
 require 'thread'
 require 'asciify'
 
+module Codegraph
+  VERSION = '0.7.11'
+end
+
 class FunctionGraph < RGL::DirectedAdjacencyGraph
    attr_accessor :funx, :adds, :excludes, :debug
 
@@ -19,20 +23,6 @@ class FunctionGraph < RGL::DirectedAdjacencyGraph
              '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"
    @@matchBeforFuncName = '[^A-z0-9_]\s*'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 7
-  - 8
-  version: 0.7.8
+  - 11
+  version: 0.7.11
 platform: ruby
 authors: 
 - Ralf Mueller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-18 14:41:19 +01:00
+date: 2011-02-14 14:51:03 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency