rubymirrors 0.0.1

data/spec/frame_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'fixtures/stack_frame_spec'
+
+describe "StackFrameMirror" do
+  before(:each) do
+    @r = reflection
+    @t = Thread.start do
+      t = FrameFixture.new
+      t.my_stop("argument_value")
+      t.my_return
+    end
+    Thread.pass until @t.stop?
+    @m = @r.reflect(@t)
+    @s = @m.stack
+    @f = @s.detect {|frame| frame.name == "my_stop" }
+  end
+
+  it "should return StackFrameMirrors when reflecting on a Threads stack" do
+    @s.each {|a| a.should be_kind_of Reflection::StackFrameMirror }
+  end
+
+  it "the step offset" do
+    @f.step_offset.should be_kind_of Fixnum
+  end
+
+  it "the source offset" do
+    offs = @f.source_offset
+    offs.should be_kind_of Fixnum
+    offs.should < @f.method.source.size
+  end
+
+  it "the receiver" do
+    @f.receiver.target_class.name.should == "FrameFixture"
+  end
+
+  it "the self should be the receiver for a regular method" do
+    @f.self.reflectee.should == @f.receiver.reflectee
+  end
+
+  it "the arguments" do
+    @f.arguments.keys.should == ["argument"]
+    @f.arguments.values.collect(&:name).should == ["argument_value".inspect]
+  end
+
+  it "the locals" do
+    @f.locals.keys.should include "local"
+    @f.locals.values.collect(&:name).should include "local_value".inspect
+  end
+
+  it "the variable context" do
+    pending
+  end
+
+  it "restart the frame" do
+    prev_step_offset = @f.step_offset
+    @f.restart
+    @f.step_offset.should < prev_step_offset
+    @m.stack.first.should == @f
+  end
+
+  it "pop the frame" do
+    frame_before_f = @s[@s.index(@f) + 1]
+    @f.pop
+    @m.stack.first.should == frame_before_f
+  end
+
+  it "step over the current call" do
+    @f.restart
+    prev_step_offset = @f.step_offset
+    @f.step(:over)
+    @f.step_offset.should == prev_step_offset + 1
+  end
+
+  it "step into the next call" do
+    @f.restart
+    @f.step(:into)
+    @m.stack[0].should_not == @f
+    @m.stack[1].should == @f
+  end
+end

data/spec/method_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'fixtures/method_spec'
+
+describe "MethodMirror" do
+  describe "runtime reflection" do
+    describe "structural queries" do
+      before(:each) do
+        @r = Reflection.new(nil)
+        @f = MethodSpecFixture
+        m = MethodSpecFixture.instance_method(:source_location)
+        @m = @r.reflect(m)
+      end
+
+      it "file" do
+        @m.file.should == @f.new.source_location[0]
+      end
+
+      it "line" do
+        @m.line.should == (@f.new.source_location[1] - 1)
+      end
+
+      it "selector" do
+        @m.selector.should == @f.new.source_location[2]
+      end
+
+      it "defining class" do
+        @m.defining_class.name.should == @f.new.source_location[3].name
+      end
+
+      it "source" do
+        @m.source.should =~ /[__FILE__, __LINE__, __method__.to_s, self.class]/
+      end
+
+      it "line=" do
+        @m.line = 12
+        @m.line.should == 12
+      end
+
+      it "file=" do
+        @m.file = "no_file.rb"
+        @m.file.should == "no_file.rb"
+      end
+      
+      it "source=" do
+        @m.source = @m.source.sub("__FILE__", "__FILE__.to_s")
+        @m.source.should =~ /[__FILE__.to_s, __LINE__, __method__.to_s, self.class]/
+        @m.defining_class.name.should == MethodSpecFixture.name
+        m = @r.reflect MethodSpecFixture.instance_method(:source_location)
+        m.source.should =~ /[__FILE__.to_s, __LINE__, __method__.to_s, self.class]/
+      end
+    end
+
+    describe "runtime behavior queries" do
+      def method_b(a, aa, b = 1, bb = 2, *args, &block)
+        to_s
+        super
+      end
+
+      before do
+        @m = @r.reflect(method(:method_b))
+      end
+
+      describe "arguments" do
+        it "argument list" do
+          @m.arguments.should include("a", "aa", "b", "bb", "args", "block")
+        end
+
+        it "block argument" do
+          @m.block_argument.should == "block"
+        end
+
+        it "required arguments" do
+          @m.required_arguments.should include("a", "aa")
+        end
+
+        it "optional arguments" do
+          @m.optional_arguments.should include("b", "bb")
+        end
+
+        it "splat argument" do
+          @m.splat_argument.should == "args"
+        end
+      end
+
+      it "step_locations" do
+        @m.step_offsets.each do |l|
+          l.should be_kind_of(Fixnum)
+          l.should < @m.source.length
+        end
+      end
+
+      it "message sends and their offsets" do
+        @m.send_offsets.should be_kind_of(Hash)
+        @m.send_offsets.keys.should include "to_s"
+        @m.send_offsets.values.first.should be_kind_of(Fixnum)
+      end
+
+      it "ast" do
+        pending
+      end
+
+      it "bytecodes" do
+        pending
+      end
+
+      describe "protection" do
+        before do
+          @cm = @r.reflect(MethodSpecFixture)
+        end
+
+        it "is public" do
+          m = @cm.method(:method_p_public)
+          m.public?.should.be_true
+          m.protected?.should.be_false
+          m.private?.should.be_false
+        end
+
+        it "is private" do
+          m = @cm.method(:method_p_private)
+          m.public?.should.be_false
+          m.protected?.should.be_false
+          m.private?.should.be_true
+        end
+
+        it "is protected" do
+          m = @cm.method(:method_p_protected)
+          m.public?.should.be_false
+          m.protected?.should.be_true
+          m.private?.should.be_false
+        end
+      end
+
+      it "returns native code if it was JITted" do
+        pending
+      end
+
+      it "returns average execution time" do
+        @m.execution_time_average.should be_kind_of(Time)
+      end
+
+      it "can return an approximation about the overall execution time it has been on the stack for" do
+        @m.execution_time.should be_kind_of(Time)
+      end
+
+      it "returns how many percent of the total process' execution time this method was active" do
+        @m.execution_time_share.should be_kind_of(Number)
+        @m.execution_time_share.should < 1
+        @m.execution_time_share.should > 0
+      end
+
+      it "returns invocation count" do
+        ic = @m.invocation_count
+        MethodSpecFixture.new.send(@m.selector)
+        @m.invocation_count.should == (ic + 1)
+      end
+
+      it "can delete a method from its home class" do
+        c = MethodSpecFixture
+        m = @r.reflect c.instance_method(:removeable_method)
+        c.instance_methods(false).map(&:to_s).should include("removeable_method")
+        m.delete
+        c.instance_methods(false).map(&:to_s).should_not include("removeable_method")
+      end
+    end
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'fixtures/object_spec'
+
+describe "ObjectMirror" do
+  before do
+    @r = reflection
+  end
+
+  before(:each) do
+    @o = ObjectFixture.new
+    @m = @r.reflect(@o)
+  end
+
+  it "can query instance variables" do
+    vars = @m.variables
+    vars.collect(&:name).should == ["@ivar"]
+  end
+end

data/spec/reflection_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'fixtures/reflect_spec'
+
+describe Reflection do
+  it "returns the type of codebase it can work on" do
+    Reflection.codebase.should be_kind_of(Class)
+  end
+
+  describe "queries" do
+    before do
+      @r = reflection
+    end
+
+    it "finds known modules" do
+      modules = @r.modules.collect(&:name)
+      modules.should include("ReflectModule")
+      modules.should_not include("ReflectClass")
+    end
+
+    it "finds known classes" do
+      classes = @r.classes.collect(&:name)
+      classes.should include("ReflectClass")
+      classes.should_not include("ReflectModule")
+    end
+
+    it "finds known instances of something" do
+      class MyObj; end
+      class My2Obj < MyObj; end
+      a = MyObj.new
+      b = My2Obj.new
+      instances = @r.instances_of(MyObj).collect(&:name)
+      instances.should include(a.inspect)
+      instances.should_not include(b.inspect)
+    end
+
+    it "can get vm objects id" do
+      o = Object.new
+      @r.object_by_id(o.object_id).name.should == o.inspect
+    end
+
+    it "can find implementors of a method" do
+      l = @r.implementations_of("unique_reflect_fixture_method")
+      l.should be_kind_of Array
+      l.size.should == 1
+      l.first.selector.should == "unique_reflect_fixture_method"
+      l.first.defining_class.name.should == "ReflectClass"
+    end
+
+    it "can find senders of a method" do
+      l = @r.senders_of("unique_reflect_sent_method")
+      l.should be_kind_of Array
+      l.size.should == 1
+      l.first.selector.should == "unique_reflect_fixture_method"
+      l.first.defining_class.name.should == "ReflectClass"
+    end
+
+    it "returns all available threads" do
+      t = Thread.start {}
+      @r.threads.collect(&:name).should include(t.inspect)
+    end
+
+    it "reports a platform" do
+      @r.platform.should == RUBY_PLATFORM
+    end
+
+    it "reports a ruby implementation" do
+      @r.engine.should == RUBY_ENGINE
+    end
+
+    it "reports the implementation's version" do
+      @r.version.should == Object.const_get(:"#{RUBY_ENGINE.upcase}_VERSION")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+RUBY_ENGINE = 'ruby' unless defined? RUBY_ENGINE
+mirror_api  = ENV["MIRRORS"] || RUBY_ENGINE
+mirror_api  = 'rubinius' if mirror_api == 'rbx'
+
+$:.push File.expand_path("..", __FILE__)
+$:.push File.expand_path("../../lib", __FILE__)
+
+require "#{mirror_api}/reflection"
+include Object.const_get(mirror_api.capitalize)
+
+require 'spec_helper/mspec_patch'
+require 'spec_helper/multiple_reflections'
+
+class PendingError < StandardError; end
+MSpec.store :guarding_exceptions, [Reflection::CapabilitiesExceeded, PendingError]
+def pending; raise PendingError; end

data/spec/spec_helper/mspec_patch.rb

@@ -0,0 +1,29 @@
+class GuardException
+  def initialize(example, exception)
+    @message = example && example.description || "<no description>"
+    @exception = exception
+    @method = exception.backtrace.first
+  end
+
+  def finish(*args)
+    print "Skipped '#{@message}'\n\t#{@exception}\n\tin #{@method}).\n\n"
+  end
+end
+
+module MSpec
+  class << self
+    alias mspec_protect protect
+
+    def protect(location, &block)
+      wrapped_block = proc do
+        begin
+          instance_eval(&block)
+        rescue *MSpec.retrieve(:guarding_exceptions)
+          MSpec.expectation
+          MSpec.register :finish, GuardException.new(MSpec.current.state, $!)
+        end
+      end
+      mspec_protect(location, &wrapped_block)
+    end
+  end
+end

data/spec/spec_helper/multiple_reflections.rb

@@ -0,0 +1,14 @@
+require 'uri'
+
+class Object
+  def reflection
+    map = { File => proc { Reflection.new("fixtures/reflect") },
+      NilClass => proc { Reflection.new(nil) },
+      URI => proc do
+        run_drb_vm
+        Reflection.new(URI::Generic.new("drb", "127.0.0.1", "9128"))
+      end }
+    map[Reflection.codebase][]
+  end
+end
+

data/spec/thread_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'fixtures/thread_spec'
+
+describe "ThreadMirror" do
+  before(:each) do
+    @r = reflection
+    @t = Thread.start do
+      t = ThreadFixture.new
+      t.stop
+      t.return
+    end
+    @m = reflection.reflect(@t)
+    sleep 0.1 until @t.stop?
+  end
+
+  after(:each) do
+    @t.kill
+  end
+
+  describe "should query" do
+    it "the thread state" do
+      @m.status.should == "sleep"
+    end
+
+    it "the thread return value" do
+      @m.run
+      sleep 0.1 until @t.stop?
+      @m.return_value.should == ThreadFixture.new.return
+    end
+
+    it "the stack" do
+      @m.stack.collect(&:name).should include "stop"
+    end
+  end
+
+  describe "should manipulate" do
+    it "should be able to resume the thread" do
+      @m.run
+      sleep 0.1 while @t.status
+      @m.status.should == "dead"
+    end
+  end
+
+  it "should install exception blocks" do
+    @t = Thread.start do
+      t = ThreadFixture.new
+      t.stop
+      t.t_raise
+    end
+    @m = @r.reflect(@t)
+    handled = false
+    @m.handle_exception Exception do |e|
+      handled = true
+    end
+    @m.run
+    begin @t.join rescue RuntimeError end
+    handled.should == true
+  end
+
+  it "should handle the right thread exception blocks" do
+    t1 = Thread.start do
+      t = ThreadFixture.new
+      t.stop
+      t.t_raise
+    end
+    t2 = Thread.start do
+      t = ThreadFixture.new
+      t.stop
+      t.t_raise
+    end
+    m1 = @r.reflect(t1)
+    m2 = @r.reflect(t2)
+    handled = false
+    m1.handle_exception Exception do |e|
+      handled = true
+    end
+    m2.run
+    begin t2.join rescue RuntimeError end
+    handled.should == false
+    m1.run
+    begin t1.join rescue RuntimeError end
+    handled.should == true
+  end
+
+  it "should handle the many thread exception blocks" do
+    t1 = Thread.start do
+      t = ThreadFixture.new
+      t.stop
+      t.t_raise
+    end
+    t2 = Thread.start do
+      t = ThreadFixture.new
+      t.stop
+      t.t_raise
+    end
+    m1 = @r.reflect(t1)
+    m2 = @r.reflect(t2)
+    handles = []
+    m1.handle_exception Exception do |e|
+      handles << "m1"
+    end
+    m2.handle_exception Exception do |e|
+      handles << "m2"
+    end
+    m1.run
+    begin t1.join rescue RuntimeError end
+    handles.should include "m1"
+    handles.should_not include "m2"
+    m2.run
+    begin t2.join rescue RuntimeError end
+    handles.should include "m1"
+    handles.should include "m2"
+  end
+
+  describe "implement shift/reset" do
+    it "can be used to return what you want" do
+      retval = @r.reflect(Thread.current).reset do
+        @r.reflect(Thread.current).shift {|cc| cc.call "shifted" } + " test"
+      end
+
+      retval.should == "shifted test"
+    end
+
+    it "can drop the continuation" do
+      retval = @r.reflect(Thread.current).reset do
+        @r.reflect(Thread.current).shift {|cc| 1 } + 1
+      end
+
+      retval.should == 1
+    end
+
+    it "can be run and re-run" do
+      retval = @r.reflect(Thread.current).reset do
+        @r.reflect(Thread.current).shift do |cc|
+          cc.call(cc.call(1))
+        end + 1
+      end
+
+      retval.should == 3
+    end
+  end
+end