stacktrace 1.0.1 → 1.0.2

data/.autotest

@@ -1,12 +1,12 @@
 # -*- ruby -*-
-
 require 'autotest/restart'
 
-
 Autotest.add_hook :initialize do |at|
   at.add_mapping(/.*\.c/) do |f, _|
     at.files_matching(/test_.*rb$/)
   end
+   at.add_exception(%r{^\./Gemfile.lock})
+   at.add_exception("lib/stacktrace/stacktrace.bundle")
 end
 
 Autotest.add_hook :run_command do |at|

data/Manifest.txt

@@ -5,4 +5,6 @@ README.txt
 Rakefile
 bin/stacktrace
 lib/stacktrace.rb
+lib/stackframe.rb
 test/test_stacktrace.rb
+ext/stacktrace/stacktrace.c

data/README.txt

@@ -15,18 +15,22 @@ I think it only works on 1.9.3 for now, need to test
 Thread.current.stacktrace 
 stacktrace 
 
-In a simple bench it is about 3 times faster than caller due to reduced information it is reporting. 
+stacktrace accepts 3 params: first is start, second is finish, last is flags
 
-== REQUIREMENTS:
+so: 
 
-* Ruby 1.9.3 
+stacktrace(0,0) returns only 1 frame (the frame you are in) 
+stacktrace(-1,-1) returns the earliest frame 
+stacktrace(0,-1,StackFrame::Flags::METHOD | StackFrame::Flags::KLASS) will return only class and method info
 
-== INSTALL:
+== REQUIREMENTS:
 
-- TODO
+* Ruby 1.9.3
 
 == DEVELOPERS:
 
+Sam Saffron
+
 After checking out the source, run:
 
   $ rake newb

data/Rakefile

@@ -10,6 +10,12 @@ require 'rake/extensiontask'
 # Hoe.plugin :racc
 # Hoe.plugin :rcov
 # Hoe.plugin :rubyforge
+VERSION = "1.0.2"
+spec = Gem::Specification.new do |s|
+  s.name = "stacktrace"
+  s.platform = Gem::Platform::RUBY
+  s.extensions = FileList["ext/**/extconf.rb"]
+end
 
 Hoe.spec 'stacktrace' do
   developer('Sam Saffron', 'sam.saffron@gmail.com')
@@ -26,4 +32,9 @@ end
 
 Rake::Task[:test].prerequisites << :compile
 
+
+
+
+
+
 # vim: syntax=ruby

data/ext/stacktrace/stacktrace.c

@@ -0,0 +1,153 @@
+// much of this is based off reading MRI source code
+
+#include <ruby.h>
+#include <vm_core.h>
+#include <iseq.h>
+#ifdef RUBY193
+    #define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+#endif
+
+#define ST_F_METHOD     1 
+#define ST_F_KLASS      2 
+#define ST_F_FILENAME   4 
+#define ST_F_LINENUMBER 8 
+#define ST_F_ALL        15 
+
+VALUE c_StackFrame;
+
+static VALUE stacktrace(int argc, VALUE* argv, rb_thread_t *th)
+{
+  VALUE ary = rb_ary_new();
+  
+  int start = 0;
+  int finish = -1;
+  int stack_size = 0;
+  const rb_control_frame_t *cfp = th->cfp;
+  const rb_control_frame_t *tcfp;
+  const rb_control_frame_t *limit_cfp = (void *)(th->stack + th->stack_size);
+  VALUE file = Qnil;
+  int line = 0;
+  rb_iseq_t *iseq = 0;
+  ID id;
+  VALUE frame;
+  extern VALUE ruby_engine_name;
+  int flags = ST_F_ALL;
+  
+  if (argc > 0) {
+    start = NUM2INT(argv[0]);
+  }
+
+  if (argc > 1) {
+    finish = NUM2INT(argv[1]);
+  } 
+
+  if (argc > 2) {
+    flags = NUM2INT(argv[2]);
+  }
+
+  cfp += 1;
+  limit_cfp -= 2;
+
+  if (finish > 0) {
+    finish--;
+  }
+
+  if (start < 0 || finish < 0) {
+    tcfp = cfp; 
+    while (tcfp < limit_cfp) 
+    {
+	    if (tcfp->iseq != 0 && cfp->pc != 0) {
+        stack_size++;
+      }
+      else if (RUBYVM_CFUNC_FRAME_P(tcfp)) {
+        stack_size++;
+      }
+      tcfp++;
+    }
+
+    if (start < 0) {
+      start = stack_size + start;
+    }
+    if (finish < 0) {
+      finish = stack_size + finish;
+    }
+  }
+
+   // rb_warn("flags: %i", flags & ST_F_KLASS);
+    // rb_warn("test %i %i cfp: %i lcfp %i ss %i", start, finish, cfp, limit_cfp, stack_size);
+
+  while (cfp < limit_cfp) {
+    VALUE hash = 0; 
+	  if (cfp->iseq != 0 && cfp->pc != 0) {
+        if (start-- > 0) {cfp++; continue;}
+        if (finish-- < 0) break;
+        iseq = cfp->iseq;
+        frame = rb_class_new_instance(0, 0, c_StackFrame); 
+        if (iseq->defined_method_id && ((flags & ST_F_KLASS) == ST_F_KLASS)) {
+          rb_iv_set(frame, "@klass", iseq->klass);
+        }
+        if ((flags & ST_F_METHOD) == ST_F_METHOD) {
+          rb_iv_set(frame, "@method", iseq->name);
+        }
+        if ((flags & ST_F_FILENAME) == ST_F_FILENAME) {
+          rb_iv_set(frame, "@filename", iseq->filename);
+        }
+        if ((flags & ST_F_LINENUMBER) == ST_F_LINENUMBER) {
+          line = rb_vm_get_sourceline(cfp);
+          rb_iv_set(frame, "@line_number", INT2FIX(line));
+        }
+        rb_ary_push(ary, frame);
+	  }
+    else if (RUBYVM_CFUNC_FRAME_P(cfp)) {
+         if (start-- > 0) {cfp++; continue;}
+         if (finish-- < 0) break;
+         if (NIL_P(file)) file = ruby_engine_name;
+         if (cfp->me->def)
+           id = cfp->me->def->original_id;
+         else
+           id = cfp->me->called_id;
+         if (id != ID_ALLOCATOR) {
+            frame = rb_class_new_instance(0, 0, c_StackFrame); 
+            if ((flags & ST_F_KLASS) == ST_F_KLASS) {
+              rb_iv_set(frame, "@klass", cfp->me->klass);
+            }
+            if ((flags & ST_F_METHOD) == ST_F_METHOD) {
+              rb_iv_set(frame, "@method", rb_id2str(id)); 
+            }
+            rb_ary_push(ary,frame);
+           
+         } 
+    }
+	  cfp += 1;
+  }
+  return ary;
+}
+
+static VALUE rb_st_kernel_stacktrace(int argc, VALUE* argv)
+{
+  return stacktrace(argc, argv, GET_THREAD());
+}
+
+static VALUE rb_st_thread_stacktrace(int argc, VALUE* argv, VALUE thval)
+{
+  rb_thread_t *th = (rb_thread_t *)RTYPEDDATA_DATA(thval);
+
+  switch (th->status) {
+       case THREAD_RUNNABLE:
+       case THREAD_STOPPED:
+       case THREAD_STOPPED_FOREVER:
+     break;
+       case THREAD_TO_KILL:
+       case THREAD_KILLED:
+     return Qnil;
+  }
+
+  return stacktrace(argc, argv, th);
+}
+
+void Init_stacktrace()
+{
+    rb_define_global_function("stacktrace", rb_st_kernel_stacktrace, -1);
+    rb_define_method(rb_cThread, "stacktrace", rb_st_thread_stacktrace, -1);
+    c_StackFrame = rb_eval_string("StackFrame");
+}

data/lib/stackframe.rb

@@ -0,0 +1,18 @@
+class StackFrame
+  module Flags 
+    METHOD = 1
+    KLASS = 2
+    FILENAME = 4
+    LINENUMBER = 8 
+    ALL = 15
+  end
+
+  attr_accessor :line_number, :method, :klass, :filename  
+
+  def ==(other)
+    line_number == other.line_number && 
+      self.method == other.method &&
+      klass == other.klass && 
+      filename == other.filename
+  end
+end

data/lib/stacktrace.rb

@@ -1,4 +1,5 @@
+require 'stackframe'
 require 'stacktrace/stacktrace'
 class StackTrace
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/test/test_stacktrace.rb

@@ -21,26 +21,74 @@ class TestStacktrace < Test::Unit::TestCase
 
   def test_singleton_stacktrace
     frame = TestStacktrace.test_singleton[0]
-    assert_equal frame[:klass], TestStacktrace.metaclass 
-    assert_equal frame[:method], "test_singleton" 
+    assert_equal frame.klass, TestStacktrace.metaclass 
+    assert_equal frame.method, "test_singleton" 
   end
   
   def test_thread_stacktrace
     frame = Thread.current.stacktrace[0]
-    assert_equal frame[:klass], TestStacktrace
-    assert_equal frame[:method], "test_thread_stacktrace"
+    assert_equal frame.klass, TestStacktrace
+    assert_equal frame.method, "test_thread_stacktrace"
   end
 
   def test_c_func
-    p [1].map{stacktrace[0]}
+    frame = nil
+    [1].map{frame = stacktrace[1]}
+    
+    assert_equal frame.method, "map"
+    assert_equal frame.klass, Array
   end
 
-  # stacktrace is MUCH faster
-  #def test_demo_bench
-  #  Benchmark.bm(7) do |b|
-  #    b.report("caller: ") { 100000.times { caller } }
-  #    b.report("stacktrace: ") { 100000.times { stacktrace } }
-  #  end
-  #end
+  def test_filename
+    name = stacktrace[0].filename
+    assert_equal name, __FILE__
+  end
+
+  def test_linenumber 
+    line = stacktrace[0].line_number
+    assert_equal __LINE__ - 1, line
+  end
+
+  def test_skipping
+    assert_equal stacktrace(1)[0], stacktrace[(1..-1)][0]
+  end
+
+  def test_simple_range
+    assert_equal stacktrace[1..2], stacktrace(1,2)
+  end
+
+  def test_invalid_range
+    assert_equal stacktrace(1,-10000), []
+  end
+
+  def test_negative_start
+    assert_equal stacktrace(-1), [stacktrace[-1]]
+  end
+
+  def test_same_length_as_caller
+    # caller skips 1 by default
+    caller_length = caller(0).length 
+    stack_length = stacktrace.length
+    assert_equal caller_length, stack_length
+  end
+
+  def test_filter_stack
+    frame = stacktrace(0, 0, StackFrame::Flags::METHOD)[0]
+
+    assert_equal nil, frame.klass
+    assert_equal nil, frame.line_number
+    assert_equal nil, frame.filename
+  end
+
+
+  #stacktrace has similar perf
+  def test_demo_bench
+    return
+    Benchmark.bm(7) do |b|
+      b.report("caller: ") { 100000.times { caller } }
+      b.report("stacktrace: ") { 100000.times { stacktrace } }
+      b.report("stacktrace: ") { 100000.times { stacktrace(0,-1, StackFrame::Flags::METHOD | StackFrame::Flags::KLASS) } }
+    end
+  end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stacktrace
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -95,7 +95,9 @@ files:
 - Rakefile
 - bin/stacktrace
 - lib/stacktrace.rb
+- lib/stackframe.rb
 - test/test_stacktrace.rb
+- ext/stacktrace/stacktrace.c
 - ext/stacktrace/extconf.rb
 - .gemtest
 homepage: https://github.com/SamSaffron/stacktrace
@@ -112,6 +114,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 845160333
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: