kefka 0.0.1 → 0.0.2

data/Gemfile

@@ -1,6 +1,14 @@
 source "http://rubygems.org"
 
+gem "yajl-ruby"
+gem "coderay"
+gem "sinatra"
+gem "method_source"
+gem "rgl"
+
 group :development do
+  gem "pry"
+  gem "pry-doc"
   gem "rspec"
   gem "jeweler"
 end

data/README

@@ -1,6 +1,6 @@
-== Kefka
+== Kefka (Experimental)
 
-A tool for understanding unfamiliar codebases and 3rd party libraries. It shows you callgraphs for different execution paths of a program.
+A tool for understanding unfamiliar codebases and 3rd party libraries. Basic Idea is to visualize the method callgraph of a program while showing local variable values for each line of execution.
 
 == Installation
 
@@ -8,9 +8,8 @@ A tool for understanding unfamiliar codebases and 3rd party libraries. It shows
 
 == Usage
 
-From the command line ,
-
-`kefka filename.rb`
+1. From the command line , `kefka`
+2. Go to browser and point to http://localhost:4567/
 
 Examples are provided under the examples directory of kefka gem
 

data/TODO

@@ -1,5 +1,9 @@
 == TODO
 
+http://wishlabs.blogspot.ca/2011/09/interactive-dot-generated-svg-graph.html
+http://www.ibm.com/developerworks/library/l-graphvis/
+http://bl.ocks.org/1667139
+
 1st Iteration
 
 method graph

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/app.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH.unshift("#{File.expand_path(File.dirname(__FILE__))}/lib")
+
+require 'sinatra'
+require 'kefka'
+require 'yajl'
+require 'yajl/json_gem'
+
+get '/' do
+  erb :index
+end
+
+get '/callgraph' do
+  content_type :json
+
+  path = "examples/sample_a.rb"
+  file = File.open(path)
+
+  @tracer = Kefka::Tracer.new
+  @tracer.trace(file, :callgraph_handler)
+
+  graph = @tracer.method_graph
+  graph.vertices.each { |method| method.format = :html }
+  graph.to_json
+end
+
+get '/locals' do
+  content_type :json
+
+  path = "examples/sample_a.rb"
+  file = File.open(path)
+
+  tracer = Kefka::Tracer.new
+  tracer.trace(file, :local_values_handler)
+  results = tracer.local_values
+  results.to_json
+end

data/bin/kefka

@@ -3,16 +3,10 @@
 $LOAD_PATH.unshift("#{File.expand_path(File.dirname(__FILE__))}/../lib")
 
 require 'kefka'
-require 'pp'
 
-if ARGV.count < 1
-  puts "Usage: kefka [path_to_file]"
-  exit
-end
+RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
 
-path = ARGV[0]
-file = File.open(path)
+APP = "#{File.expand_path(File.dirname(__FILE__))}/../app.rb"
+exec RUBY, APP
 
-Kefka.trace(file, :callgraph_handler)
-Kefka.display
 

data/examples/sample_a.rb

@@ -0,0 +1,61 @@
+require 'forwardable'
+require 'date'
+require 'net/http'
+
+class Book
+  extend Forwardable
+  def_delegators :@store, :first, :last
+
+  def initialize
+    @store = [1,2]
+  end
+
+  def []
+    "array accessor"
+  end
+end
+
+class Displayer
+  def initialize(out)
+    @out = out
+  end
+
+  def puts(val)
+    @out.puts val
+  end
+end
+
+def hello
+  num = init
+  x = 4
+  x = x * 2
+  b = Book.new
+
+  if b.first
+    puts "lol"
+  end
+
+  c = b[]
+  display = Displayer.new($stdout)
+  display.puts "Hello #{num}"
+end
+
+def init
+  a = 1 + rand(9)
+  (0..3).each do |x|
+    a = a + time_diff
+  end
+  a
+end
+
+# function called inside a loop
+def time_diff
+  before = Time.now
+  after  = Time.now
+  (after - before).to_i
+end
+
+hello
+
+Net::HTTP.get_response(URI.parse("http://www.twitter.com")).body
+

data/kefka.gemspec

@@ -5,18 +5,17 @@
 
 Gem::Specification.new do |s|
   s.name = "kefka"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Reginald Tan"]
-  s.date = "2012-07-14"
+  s.date = "2012-07-30"
   s.description = " It traces the execution path of a program and displays the source code of each method call in the callgraph "
   s.email = "redge.tan@gmail.com"
   s.executables = ["kefka"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README",
-    "README.rdoc",
     "TODO"
   ]
   s.files = [
@@ -24,16 +23,20 @@ Gem::Specification.new do |s|
     "Gemfile",
     "LICENSE.txt",
     "README",
-    "README.rdoc",
     "Rakefile",
     "VERSION",
+    "app.rb",
     "bin/kefka",
-    "examples/sample1.rb",
+    "examples/sample_a.rb",
     "examples/trace_specific_lines.rb",
     "kefka.gemspec",
     "lib/kefka.rb",
+    "public/javascripts/app.js",
+    "public/javascripts/jquery-1.7.2.js",
+    "public/stylesheets/application.css",
     "test/helper.rb",
-    "test/test_kefka.rb"
+    "test/test_kefka.rb",
+    "views/index.erb"
   ]
   s.homepage = "http://github.com/redgetan/kefka"
   s.licenses = ["MIT"]
@@ -45,13 +48,34 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<yajl-ruby>, [">= 0"])
+      s.add_runtime_dependency(%q<coderay>, [">= 0"])
+      s.add_runtime_dependency(%q<sinatra>, [">= 0"])
+      s.add_runtime_dependency(%q<method_source>, [">= 0"])
+      s.add_runtime_dependency(%q<rgl>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<pry-doc>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
     else
+      s.add_dependency(%q<yajl-ruby>, [">= 0"])
+      s.add_dependency(%q<coderay>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<method_source>, [">= 0"])
+      s.add_dependency(%q<rgl>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<pry-doc>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
     end
   else
+    s.add_dependency(%q<yajl-ruby>, [">= 0"])
+    s.add_dependency(%q<coderay>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<method_source>, [">= 0"])
+    s.add_dependency(%q<rgl>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<pry-doc>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
   end

data/lib/kefka.rb

@@ -1,14 +1,117 @@
-module Kefka
+require 'coderay'
+require 'rgl/adjacency'
+require 'rgl/dot'
+require 'method_source'
 
-  @@values = {}
-  @@method_source = {}
+require 'forwardable'
+require 'logger'
 
-  class << self
+class Kefka
 
-    def get_values_of_locals_from_binding(binding)
-      locals = binding.eval("local_variables")
+  class Method
+
+    attr_reader :classname, :id, :file, :line, :caller
+    attr_accessor :format
+
+    def initialize(options={})
+      @classname = options[:classname]
+      @id        = options[:id]
+      @file      = options[:file]
+      @line      = options[:line]
+      @format    = options[:format] || :plain
+    end
+
+    def source_location
+      return nil unless @file && @line
+      [@file,@line]
+    end
+
+    def end_line
+      return nil unless @line && source
+      @line + source.lines.count - 1
+    end
+
+    def key
+      source_location ? source_location.join(":") : nil
+    end
+
+    def contains?(file, line)
+      @file == file && @line < line && end_line > line
+    end
+
+    def source
+      @source ||= begin
+                    MethodSource.source_helper(source_location)
+                  rescue MethodSource::SourceNotFoundError => e
+                    warn "Warning: #{e.class} #{e.message}"
+                    nil
+                  end
+    end
+
+    def formatted_source
+      if @format == :html
+        CodeRay.scan(source, :ruby)
+               .div(:line_numbers => :table, :line_number_start => @line)
+      else
+        source
+      end
+    end
+
+    def to_s
+      "#{classname} #{id}"
+    end
+
+    def to_json(*a)
+      {
+        :classname => @classname,
+        :id => @id,
+        :file => @file,
+        :line => @line,
+        :end_line => end_line,
+        :source => formatted_source
+      }.to_json(*a)
+    end
+  end
+
+  class MethodGraph
+    extend Forwardable
+    def_delegators :@graph, :vertices, :edges, :add_edge,
+                   :write_to_graphic_file
+
+    def initialize
+      @graph =  RGL::DirectedAdjacencyGraph.new
+    end
+
+    def to_json
+      {
+        :vertices => vertices,
+        :edges => edges.map { |edge|
+          {
+            :source => edge.source.key,
+            :target => edge.target.key
+          }
+        }
+      }.to_json
+    end
+  end
+
+  class Tracer
+
+    attr_reader :method_table, :local_values, :logger, :callstack, :method_graph
+
+    def initialize(log_level = Logger::INFO)
+      @method_graph = MethodGraph.new
+      @callstack = []
+      @local_values = {}
+      @event_disable = []
+      @logger = Logger.new($stderr)
+      @logger.level = log_level
+    end
+
+    def get_values_of_locals_from_binding(target)
+      locals = target.eval("local_variables")
       locals.inject({}) do |result,l|
-        val = binding.eval(l.to_s)
+        val = target.eval(l.to_s)
         val = begin
                 # deep copy
                 Marshal.load(Marshal.dump(val)) if val
@@ -21,100 +124,85 @@ module Kefka
       end
     end
 
-    # Things to IGNORE
-    # 1. loading of rubygems/libraries
+    def disable_event_handlers?
+      !@event_disable.empty?
+    end
+
     def callgraph_handler(event, file, line, id, binding, classname)
-      # do not trace current file (TODO: and anything in this library)
       return if file == __FILE__
+
+      @logger.debug "#{event} - #{file}:#{line} #{classname} #{id}"
+
+      if disable_event_handlers?
+        @event_disable.pop if event == "end"
+        return
+      end
+
       case event
+      when "class"
+        @event_disable << true
       when "call"
-        # mark the start of method call
-
-        # key must be uniquely identifiable -
-        # Class methodname is not enough
-        # perhaps include:
-        #   1. line
-        #   2. file
-        key = "#{classname}_#{id}"
-        @@method_source[key] = [file, caller[1], line]
-      when "line"
+        method_caller = @callstack.last
+
+        method = Method.new(
+          :classname => classname,
+          :id => id,
+          :file => file,
+          :line => line
+        )
+
+        if method_caller
+          @method_graph.add_edge(method_caller,method)
+        end
+
+        @callstack << method
       when "return"
-        key = "#{classname}_#{id}"
-        @@method_source[key] << line if @@method_source[key]
+        @callstack.pop
       else
         # do nothing
       end
     rescue Exception => e
-      puts "#{e.message} from  --  #{e.backtrace.join("\n")}"
+      puts "\n#{e.class}: #{e.message} \n    from #{e.backtrace.join("\n")}"
+      Process.kill("KILL", $$)
     end
 
-    def locals_values_handler(event, file, line, id, binding, classname)
-
+    def local_values_handler(event, file, line, id, binding, classname)
+      # skip variables that should not be tracked
+      # 1. anything in current lib (i.e __FILE__)
+      # 2. all local variables that are in TOP LEVEL BINDING before tracing
+      #     - but these variables may be overwritten by the traced program,
+      #       excluding them would mean not displaying certain relevant
+      #       vars in that program
       return if file == __FILE__
 
+      @logger.debug "#{event} - #{file}:#{line} #{classname} #{id}" if $DEBUG
+
+      if disable_event_handlers?
+        @event_disable.pop if event == "end"
+        return
+      end
+
       case event
-      when "call"
-        #puts "Entering method #{classname} - #{id}"
+      when "class"
+        @event_disable << true
       when "line"
-        # variables that should not be tracked
-        # 1. anything in current lib
-        # 2. all local variables that are in TOP LEVEL BINDING before tracing
-        #     - but these variables may be overwritten by the traced program,
-        #       excluding them would mean not displaying certain relevant
-        #       vars in that program
-        key = "#{file}_#{line}".to_sym
-        @@values[key] = get_values_of_locals_from_binding(binding)
+        key = [file, line].join(":")
+        @local_values[key] = get_values_of_locals_from_binding(binding)
       else
         # do nothing
       end
     end
 
-    def start(handler)
-      set_trace_func method(handler).to_proc
-    end
-
-    def stop
-      set_trace_func nil
-    end
-
-    def trace(file, handler = :callgraph_handler)
-      puts "\nTracing Execution using #{handler}...\n\n"
-      start(handler)
-      file.rewind if file.eof?
-      code = file.read
-      eval(code, TOPLEVEL_BINDING, file.path, 1)
-      stop
-    end
-
-    def method_graph
-      @@method_source
-    end
-
-    def display
-      puts "\n==== Generating Method Callgraph...\n\n"
-      @@method_source.each do |meth,props|
-        puts
-        puts meth
-        puts
-
-        file, parent_caller, start_line, finish_line = props
-
-        File.open(file) { |f|
-          (start_line - 1).times { f.readline }
-
-          code = ""
-          (finish_line - start_line + 1).times {
-            code << f.readline
-          }
-          puts code
-        }
+    def trace(file_path, handler = :callgraph_handler)
+      file = File.open(file_path)
 
-        puts
-      end
-    end
+      thread = Thread.new {
+        code = file.read
+        eval(code, TOPLEVEL_BINDING, file.path, 1)
+      }
 
-    def values
-      @@values
+      thread.set_trace_func method(handler).to_proc
+      thread.join
     end
 
   end