kefka 0.0.4 → 0.0.5

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/app.rb

@@ -18,25 +18,29 @@ get '/callgraph' do
   @tracer.trace(file_path)
 
   # input code
-  input = CodeRay.scan(@tracer.code, :ruby).div(:line_numbers => :table)
+  #input = CodeRay.scan(@tracer.code, :ruby).div(:line_numbers => :table)
 
-  graph = @tracer.method_graph
+  method_graph = @tracer.method_graph
 
   # output call graph using dot if graphviz is installed
-  if is_graphviz_installed = system("which dot")
-    graph.write_to_graphic_file("png", "#{File.expand_path(File.dirname(__FILE__))}/public/graph")
-  end
+  #if is_graphviz_installed = system("which dot")
+  #  method_graph.write_to_graphic_file("png", "#{File.expand_path(File.dirname(__FILE__))}/public/graph")
+  #end
 
   # html code graph
-  graph.vertices.each { |method| method.format = :html }
+  method_graph.vertices.each { |method| method.format = :html }
+
+  # line graph
+  line_graph = @tracer.line_graph
 
   # locals
   locals = @tracer.local_values
 
   {
-    :input => input,
-    :is_graphviz_installed => is_graphviz_installed,
-    :graph => graph,
+    #:input => input,
+    #:is_graphviz_installed => is_graphviz_installed,
+    :vertices => method_graph.vertices,
+    :edges => line_graph.edges,
     :locals => locals
   }.to_json
 end

data/kefka.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "kefka"
-  s.version = "0.0.4"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Reginald Tan"]
-  s.date = "2012-08-18"
+  s.date = "2012-08-27"
   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"]
@@ -33,6 +33,7 @@ Gem::Specification.new do |s|
     "lib/kefka.rb",
     "public/javascripts/app.js",
     "public/javascripts/jquery-1.7.2.js",
+    "public/javascripts/underscore.js",
     "public/stylesheets/application.css",
     "spec/fixture/sample_a.rb",
     "spec/kekfa_spec.rb",

data/lib/kefka.rb

@@ -9,10 +9,42 @@ require 'logger'
 
 class Kefka
 
+  class Call
+    attr_accessor :method, :line
+
+    def initialize(options={})
+      @method = options[:method]
+      @line = options[:line]
+    end
+
+    def file
+      @method.file
+    end
+
+    def to_s
+      "#{@method.file}:#{@line} in #{@method}"
+    end
+
+    def key
+      [@method.id,@method.file,@line].join(":")
+    end
+
+    def eql?(other)
+      self.key == other.key
+    end
+
+    alias :== :eql?
+
+    def hash
+      [@method.file,@line].hash
+    end
+
+  end
+
   class Method
 
     attr_reader :classname, :id, :file, :line
-    attr_accessor :source, :format
+    attr_accessor :source, :format, :depth
 
     def initialize(options={})
       raise ArgumentError, "missing file + line" unless options[:file] && options[:line]
@@ -32,7 +64,7 @@ class Kefka
     end
 
     def key
-      source_location ? source_location.join(":") : nil
+      source_location ? [id,source_location].flatten.join(":") : nil
     end
 
     def contains?(file, line)
@@ -80,44 +112,95 @@ class Kefka
     def to_json(*a)
       {
         :classname => @classname,
-        :id => @id,
+        :id => @id.to_s,
         :file => @file,
         :line => @start_line,
         :end_line => end_line,
+        :depth => depth,
         :source => formatted_source
       }.to_json(*a)
     end
   end
 
+  # shows which method called which method
   class MethodGraph
     extend Forwardable
-    def_delegators :@graph, :vertices, :edges, :add_edge,
-                   :write_to_graphic_file
+    def_delegators :@graph, :vertices, :edges, :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
-          }
+    def assign_depth(u,v)
+      u.depth = 0 unless u.depth
+      v.depth = u.depth + 1
+    end
+
+    def add_edge(u,v)
+      raise ArgumentError unless Method === u && Method === v
+      assign_depth(u,v)
+      @graph.add_edge(u,v)
+    end
+  end
+
+  # shows which line in a method called which method
+  class LineGraph
+    extend Forwardable
+    def_delegators :@graph, :vertices, :write_to_graphic_file
+
+    def initialize
+      @graph =  RGL::DirectedAdjacencyGraph.new
+    end
+
+    def add_edge(u,v)
+      raise ArgumentError unless Call === u && Method === v
+      @graph.add_edge(u,v)
+    end
+
+    def edges
+      @graph.edges.map { |edge|
+        {
+          :source => edge.source.key,
+          :target => edge.target.key
         }
-      }.to_json
+      }
+    end
+  end
+
+  module LocalsHelper
+    # @target - binding
+    def self.get_locals(target, line_source)
+      scope_locals = target.eval("local_variables")
+      scope_locals.map! { |local| local.to_s }
+
+      tokens = Ripper.lex(line_source)
+
+      lvar, ivar, cvar = [], [], []
+
+      tokens.each { |token|
+        type = token[1]
+
+        case type
+        when :on_ident; lvar << token[2] if scope_locals.include? token[2]
+        when :on_ivar;  ivar << token[2]
+        when :on_cvar;  cvar << token[2]
+        else # do nothing
+        end
+      }
+
+      [lvar,ivar,cvar].flatten
     end
   end
 
   class Tracer
 
-    attr_reader :local_values, :logger, :callstack, :method_graph,
+    attr_reader :local_values, :logger, :callstack,
+                :method_graph, :line_graph,
                 :code
 
     def initialize(log_level = Logger::INFO)
       @method_graph = MethodGraph.new
+      @line_graph = LineGraph.new
       @callstack = []
       @local_values = {}
       @event_disable = []
@@ -130,7 +213,8 @@ class Kefka
 
       thread = Thread.new {
         @code = file.read
-        #@callstack << create_top_level_method(file_path)
+        toplevel_method = create_toplevel_method(file_path)
+        @callstack << Call.new(:method => toplevel_method, :line => 1)
         eval(@code, TOPLEVEL_BINDING, file.path, 1)
       }
 
@@ -157,7 +241,8 @@ class Kefka
       when "class"
         @event_disable << true
       when "call"
-        method_caller = @callstack.last
+        called_from = @callstack.last
+        caller_method = called_from.method
 
         method = Method.new(
           :classname => classname,
@@ -166,11 +251,10 @@ class Kefka
           :line => line
         )
 
-        if method_caller
-          @method_graph.add_edge(method_caller,method)
-        end
+        @line_graph.add_edge(called_from.dup,method)
+        @method_graph.add_edge(caller_method,method)
 
-        @callstack << method
+        @callstack << Call.new(:method => method, :line => line)
       when "line"
         # skip variables that should not be tracked
         # 1. anything in current lib (i.e __FILE__)
@@ -180,6 +264,10 @@ class Kefka
         #       vars in that program
         #current_method = @callstack.last
 
+        # update callstack last method's line
+        if call = @callstack.last
+          call.line = line
+        end
         # given current file & line, determine what method I am in
 
         method = @method_graph.vertices
@@ -190,7 +278,7 @@ class Kefka
         if method
           line_source = method.source_at_line(line)
 
-          iseq_key = [file, line].join(":")
+          iseq_key = [id,file,line].join(":")
           @local_values[iseq_key] = get_values_of_locals_from_binding(binding, line_source)
         end
       when "return"
@@ -204,31 +292,15 @@ class Kefka
     end
 
     def get_values_of_locals_from_binding(target, line_source)
-      locals = get_locals(target,line_source)
+      locals = LocalsHelper.get_locals(target,line_source)
       locals.inject({}) do |result,l|
         val = target.eval(l.to_s)
         val = deep_copy(val)
-        result.merge!({ l => val })
+        result.merge!({ l => val.to_s })
         result
       end
     end
 
-    def get_locals(target, line_source)
-      scope_locals = target.eval("local_variables")
-      scope_locals.map! { |local| local.to_s }
-
-      tokens = Ripper.lex(line_source)
-
-      tokens.select! { |token|
-        type = token[1]
-        type == :on_ident || type == :on_ivar || type == :on_cvar
-      }
-
-      possible_line_variables = tokens.map { |token| token[2] }
-      line_variables = scope_locals & possible_line_variables
-      line_variables
-    end
-
     def deep_copy(val)
       Marshal.load(Marshal.dump(val))
     rescue TypeError
@@ -236,14 +308,14 @@ class Kefka
     end
 
 
-    def create_top_level_method(file)
+    def create_toplevel_method(file_path)
       method = Method.new(
-        :classname => "Object",
-        :id => "<main>",
-        :file => file,
+        :classname => "Toplevel",
+        :id => nil,
+        :file => file_path,
         :line => 1
       )
-      method.source = File.readlines(file).join
+      method.source = File.readlines(file_path).join
       return method
     end
 

data/public/javascripts/app.js

@@ -2,13 +2,6 @@ var jqSelectorEscape = function(text) {
   return text.replace(/([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, "\\$&");
 };
 
-var outputTrace = function(data) {
-  displayInput(data.input);
-  displayGraphiz(data.is_graphviz_installed);
-  createCodeBubbles(data.graph);
-  displayLocals(data.locals);
-}
-
 var displayInput = function(input) {
   $("div#input").last().append(input);
 };
@@ -21,58 +14,137 @@ var displayGraphiz = function(is_graphviz_installed) {
   }
 };
 
-var createCodeBubbles = function(graph) {
-  console.log(graph);
+var setupBubble = function(bubble, method) {
+  var $bubble, xPos, key, header;
 
-  var xPos = 0;
-  var bubbleDiv, $bubble, $code,
-      key, header,
-      lineCount, column;
+  $bubble = bubble;
 
-  var methods = graph.vertices;
+  $bubble.append(method.source);
 
-  for (var i = 0; i < methods.length; i++ )
-  {
-    bubbleDiv = "<div class='bubble'></div>";
-    $(bubbleDiv).appendTo("#codeGraph");
+  // set id for bubble table
+  key = method.id + ":" + method.file + ":" + method.line;
+  $bubble.attr("id",key);
 
-    $bubble = $("#codeGraph .bubble").last();
-    $bubble.append(methods[i].source);
+  // set header of bubble div
+  header = method.file + ":" + method.line;
+  $bubble.prepend("<pre><span class='methodHeader'>" + header + "</span></pre>");
 
-    // set id for bubble table
-    key = methods[i].file + ":" + methods[i].line;
-    $bubble.attr("id",key);
+  // set column position
+  xPos = method.depth * 200;
 
-    // set header of bubble div
-    header = methods[i].file + ":" + methods[i].line;
-    $bubble.prepend("<pre><span class='methodHeader'>" + header + "</span></pre>");
+  // position bubble table
+  $bubble.css("position", "relative")
+         .css("left", xPos);
 
-    //callerKey = methodTable[key].caller.method.key;
-    //$callerBubble = $("div.bubble#" + jqSelectorEscape(callerKey));
-    //xPos = $callerBubble.position().left + 200;
+  // hide bubbles in deeper levels
 
-    // position bubble table
-    $bubble.css("position", "relative")
-           .css("left", xPos);
+  if (method.depth != 0) {
+    $bubble.hide();
+  }
+};
 
-    // add column for displaying local values
-    lineCount = $bubble.find("td.line-numbers a").length;
+var addExpandColumn = function(bubble,method) {
+  var column, $code, $bubble;
 
-    column = "<td class='locals'>";
-    column += "<pre>";
+  $bubble = bubble;
 
-    for (var j = methods[i].line; j < methods[i].line + lineCount; j++)
-    {
-      column += "<span id='line" + j + "'></span>\n";
-    }
+  column = "<td class='expand'>";
+  column += "<pre>";
 
-    column += "</pre>";
-    column += "</td>";
+  for (var j = method.line; j <= method.end_line ; j++)
+  {
+    column += "<span id='line" + j + "'></span>\n";
+  }
+
+  column += "</pre>";
+  column += "</td>";
+
+  $code = $bubble.find("td.code");
+  $code.after(column);
+};
+
+var addLocalsColumn = function(bubble,method) {
+  var column, $expand, $bubble;
+
+  $bubble = bubble;
 
-    $code = $bubble.find("td.code");
-    $code.after(column);
+  column = "<td class='locals'>";
+  column += "<pre>";
 
+  for (var j = method.line; j <= method.end_line; j++)
+  {
+    column += "<span id='line" + j + "'></span>\n";
   }
+
+  column += "</pre>";
+  column += "</td>";
+
+  $expand = $bubble.find("td.expand");
+  $expand.after(column);
+};
+
+var setupCall = function(call, edges) {
+  var keyTokens, methodName, file, line,
+      $bubbles, $line;
+
+  keyTokens = call.split(":");
+  methodName = keyTokens[0];
+  file       = keyTokens[1];
+  line       = keyTokens[2];
+
+  $bubbles = $("div.bubble").filter(function(){
+    return this.id.match(methodName) && this.id.match(file);
+  });
+
+  $line = $bubbles.find("td.expand span#line" + line).first();
+  $line.data("key",call);
+
+  $line.html("<div class='expand'>+</div>");
+  $line.find("div.expand").first().click(function() {
+    return function(that){
+      _.chain(edges)
+        .filter( function(edge){ return edge.source == $(that).parent().data("key"); })
+        .map(    function(edge){ console.log(edge);return edge.target })
+        .each(   function(target){
+          $("#codeGraph .bubble#" + jqSelectorEscape(target))
+            .first()
+            .toggle();
+      });
+    }(this);
+  });
+
+};
+
+var createCodeBubbles = function(vertices,edges) {
+  console.log(vertices);
+  console.log(edges);
+
+  var xPos = 0;
+  var bubbleDiv, $bubble;
+
+  var methods = vertices;
+
+  _.each(methods, function(method){
+    bubbleDiv = "<div class='bubble'></div>";
+    $(bubbleDiv).appendTo("#codeGraph");
+
+    $bubble = $("#codeGraph .bubble").last();
+
+    setupBubble($bubble, method);
+    addExpandColumn($bubble,method);
+    addLocalsColumn($bubble,method);
+  });
+
+  var calls = _.map(edges, function(edge) { return edge.source });
+
+  // for each call, get the source (key -> method:line)
+  // add an 'expand' button on the source
+  // on button, add click handler that will
+
+  _.each(calls, function(call){
+    setupCall(call, edges);
+  });
+
 };
 
 var displayLocals = function(locals) {
@@ -93,11 +165,12 @@ var displayLocals = function(locals) {
     }
 
     keys = key.split(":");
-    file = keys[0];
-    line = keys[1];
+    methodName = keys[0];
+    file = keys[1];
+    line = keys[2];
 
     $bubbles = $("div.bubble").filter(function(){
-      return this.id.match(file);
+      return this.id.match(methodName) && this.id.match(file);
     });
 
     $line = $bubbles.find("td.locals span#line" + line).first();
@@ -105,6 +178,13 @@ var displayLocals = function(locals) {
   }
 };
 
+var outputTrace = function(data) {
+  //displayInput(data.input);
+  //displayGraphiz(data.is_graphviz_installed);
+  createCodeBubbles(data.vertices,data.edges);
+  displayLocals(data.locals);
+}
+
 $(document).ready(function(){
 
   $.ajax({