stacktrace 1.0.0

data/.autotest

@@ -0,0 +1,34 @@
+# -*- 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|
+  system "rake clean compile"
+end
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,5 @@
+=== 1.0.0 / 2012-06-01
+
+* Initial version of stacktrace, only compatible with 1.9.3 for now
+
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/stacktrace
+lib/stacktrace.rb
+lib/stackframe.rb
+test/test_stacktrace.rb
+ext/stacktrace/stacktrace.c

data/README.txt

@@ -0,0 +1,58 @@
+= stacktrace
+
+* https://github.com/SamSaffron/stacktrace
+
+== DESCRIPTION:
+
+The idea here is to have a more efficient and useful stacktrace than caller. Caller does not provide you with any class info. 
+
+== FEATURES/PROBLEMS:
+
+I think it only works on 1.9.3 for now, need to test
+
+== SYNOPSIS:
+
+Thread.current.stacktrace 
+stacktrace 
+
+In a simple bench it is about 3 times faster than caller due to reduced information it is reporting. 
+
+== REQUIREMENTS:
+
+* Ruby 1.9.3
+
+== DEVELOPERS:
+
+Sam Saffron
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 Sam Saffron
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'rake/extensiontask'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+# Hoe.plugin :rubyforge
+VERSION = "1.0.0"
+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')
+
+  self.rubyforge_name = 'stacktrace' # if different than 'stacktrace'
+  self.extra_dev_deps << ['rake-compiler', '>=0']
+  self.spec_extras = {:extensions => ["ext/stacktrace/extconf.rb"]}
+
+  Rake::ExtensionTask.new('stacktrace', spec) do |ext|
+    ext.lib_dir = File.join('lib', 'stacktrace')
+  end
+end
+
+Rake::Task[:test].prerequisites << :compile
+
+
+
+
+
+
+# vim: syntax=ruby

data/bin/stacktrace

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/ext/stacktrace/extconf.rb

@@ -0,0 +1,16 @@
+require 'mkmf'
+require 'ruby_core_source'
+
+def add_define(name)
+  $defs.push("-D#{name}")
+end
+
+hdrs = proc {
+  have_header('vm_core.h')
+  have_header('iseq.h')
+}
+major, minor, patch = RUBY_VERSION.split('.').map!(&:to_i)
+add_define 'RUBY19'
+add_define 'RUBY193' if patch >= 3
+
+Ruby_core_source::create_makefile_with_core(hdrs, 'stacktrace/stacktrace')

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

@@ -0,0 +1,2 @@
+require 'stackframe'
+require 'stacktrace/stacktrace'

data/test/test_stacktrace.rb

@@ -0,0 +1,94 @@
+require "test/unit"
+require "stacktrace"
+require "benchmark"
+
+class Object
+  def metaclass; class << self; self; end; end
+end
+
+class TestStacktrace < Test::Unit::TestCase
+  def test_we_get_an_array
+    assert_equal Array, stacktrace.class
+  end
+
+  def test_we_get_items_in_our_array
+    assert stacktrace.length > 0
+  end
+
+  def self.test_singleton
+    stacktrace
+  end
+
+  def test_singleton_stacktrace
+    frame = TestStacktrace.test_singleton[0]
+    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"
+  end
+
+  def test_c_func
+    frame = nil
+    [1].map{frame = stacktrace[1]}
+    
+    assert_equal frame.method, "map"
+    assert_equal frame.klass, Array
+  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

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: stacktrace
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sam Saffron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: The idea here is to have a more efficient and useful stacktrace than
+  caller. Caller does not provide you with any class info.
+email:
+- sam.saffron@gmail.com
+executables:
+- stacktrace
+extensions:
+- ext/stacktrace/extconf.rb
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+- README.txt
+files:
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- 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
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.txt
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3361579644017678061
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: stacktrace
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: The idea here is to have a more efficient and useful stacktrace than caller
+test_files:
+- test/test_stacktrace.rb