peeek 1.0.1

data/lib/peeek/version.rb

@@ -0,0 +1,3 @@
+class Peeek
+  VERSION = '1.0.1'
+end

data/peeek.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'peeek/version'
+
+Gem::Specification.new do |spec|
+  spec.name                  = 'peeek'
+  spec.version               = Peeek::VERSION
+  spec.authors               = ['Takahiro Kondo']
+  spec.email                 = ['heartery@gmail.com']
+  spec.description           = %q{Peek at calls of a method}
+  spec.summary               = spec.description
+  spec.homepage              = 'https://github.com/takkkun/peeek'
+  spec.license               = 'MIT'
+  spec.required_ruby_version = '>= 1.8.7'
+
+  spec.files                 = `git ls-files`.split($/)
+  spec.executables           = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files            = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths         = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/spec/peeek/call_spec.rb

@@ -0,0 +1,226 @@
+require 'peeek/call'
+
+def sample_call(attrs = {})
+  hook   = attrs[:hook] || stub('Peeek::Hook', :to_s => 'String#%')
+  args   = attrs[:args] || ['Koyomi', 18]
+  result = attrs[:result] || Peeek::Call::ReturnValue.new('Koyomi (18)')
+  Peeek::Call.new(hook, sample_backtrace, '%s (%d)', args, result)
+end
+
+def sample_backtrace
+  ["koyomi.rb:7:in `print'", "koyomi.rb:21:in `<main>'"]
+end
+
+def sample_return_value
+  Peeek::Call::ReturnValue.new(:return_value)
+end
+
+def sample_exception
+  Peeek::Call::Exception.new(:exception)
+end
+
+describe Peeek::Call, '#initialize' do
+  it 'raises ArgumentError if the result is invalid' do
+    lambda { sample_call(:result => :result) }.should raise_error(ArgumentError, 'invalid as result')
+  end
+end
+
+describe Peeek::Call, '#hook' do
+  it 'returns the value when constructed the call' do
+    hook = :hook
+    call = sample_call(:hook => hook)
+    call.hook.should == hook
+  end
+end
+
+describe Peeek::Call, '#backtrace' do
+  it 'returns the value when constructed the call' do
+    call = sample_call
+    call.backtrace.should == sample_backtrace
+  end
+end
+
+describe Peeek::Call, '#file' do
+  it 'returns name of top file on the backtrace' do
+    call = sample_call
+    call.file.should == 'koyomi.rb'
+  end
+end
+
+describe Peeek::Call, '#line' do
+  it 'returns top line number on the backtrace' do
+    call = sample_call
+    call.line.should == 7
+  end
+end
+
+describe Peeek::Call, '#receiver' do
+  it 'returns the value when constructed the call' do
+    call = sample_call
+    call.receiver.should == '%s (%d)'
+  end
+end
+
+describe Peeek::Call, '#arguments' do
+  it 'returns the value when constructed the call' do
+    call = sample_call
+    call.arguments.should == ['Koyomi', 18]
+  end
+end
+
+describe Peeek::Call, '#result' do
+  it 'returns the value when constructed the call' do
+    result = sample_return_value
+    call = sample_call(:result => result)
+    call.result.should == result
+  end
+end
+
+describe Peeek::Call, '#return_value' do
+  it 'returns value of the result' do
+    call = sample_call(:result => sample_return_value)
+    call.return_value.should == :return_value
+  end
+
+  it 'raises TypeError if the call is raised an exception' do
+    call = sample_call(:result => sample_exception)
+    lambda { call.return_value }.should raise_error(TypeError, "the call didn't return a value")
+  end
+end
+
+describe Peeek::Call, '#exception' do
+  it 'returns value of the result' do
+    call = sample_call(:result => sample_exception)
+    call.exception.should == :exception
+  end
+
+  it 'raises TypeError if the call returned a value' do
+    call = sample_call(:result => sample_return_value)
+    lambda { call.exception }.should raise_error(TypeError, "the call didn't raised an exception")
+  end
+end
+
+describe Peeek::Call, '#returned?' do
+  it 'is true if the call returned a value' do
+    call = sample_call(:result => sample_return_value)
+    call.should be_returned
+  end
+
+  it 'is false if the call is raised an exception' do
+    call = sample_call(:result => sample_exception)
+    call.should_not be_returned
+  end
+end
+
+describe Peeek::Call, '#raised?' do
+  it 'is true if the call is raised an exception' do
+    call = sample_call(:result => sample_exception)
+    call.should be_raised
+  end
+
+  it 'is false if the call returned a value' do
+    call = sample_call(:result => sample_return_value)
+    call.should_not be_raised
+  end
+end
+
+describe Peeek::Call, '#to_s' do
+  context 'with no arguments' do
+    it 'returns the stringified call' do
+      call = sample_call(:args => [])
+      call.to_s.should == 'String#% from "%s (%d)" returned "Koyomi (18)" in koyomi.rb at 7'
+    end
+  end
+
+  context 'with an argument' do
+    it 'returns the stringified call' do
+      call = sample_call(:args => [:arg])
+      call.to_s.should == 'String#% from "%s (%d)" with :arg returned "Koyomi (18)" in koyomi.rb at 7'
+    end
+  end
+
+  context 'with multiple arguments' do
+    it 'returns the stringified call' do
+      call = sample_call(:args => [:arg1, :arg2])
+      call.to_s.should == 'String#% from "%s (%d)" with (:arg1, :arg2) returned "Koyomi (18)" in koyomi.rb at 7'
+    end
+  end
+
+  context 'with a return value result' do
+    it 'returns the stringified call' do
+      call = sample_call(:result => sample_return_value)
+      call.to_s.should == 'String#% from "%s (%d)" with ("Koyomi", 18) returned :return_value in koyomi.rb at 7'
+    end
+  end
+
+  context 'with an exception result' do
+    it 'returns the stringified call' do
+      call = sample_call(:result => sample_exception)
+      call.to_s.should == 'String#% from "%s (%d)" with ("Koyomi", 18) raised :exception in koyomi.rb at 7'
+    end
+  end
+end
+
+describe Peeek::Call::ReturnValue do
+  it 'inhertis Peeek::Call::Result' do
+    result = described_class.allocate
+    result.should be_a(Peeek::Call::Result)
+  end
+
+  it 'identifies as key in a hash' do
+    hash = {sample_return_value => :return_value}
+    hash.should     be_key(sample_return_value)
+    hash.should_not be_key(sample_exception)
+    hash.should_not be_key(described_class.new(:other_return_value))
+    hash.should_not be_key(Peeek::Call::Exception.new(:return_value))
+  end
+end
+
+describe Peeek::Call::ReturnValue, '#value' do
+  it 'returns the value when constructed the result' do
+    result = sample_return_value
+    result.value.should == :return_value
+  end
+end
+
+describe Peeek::Call::ReturnValue, '#==' do
+  it 'verifies equivalency' do
+    result = sample_return_value
+    result.should     == sample_return_value
+    result.should_not == sample_exception
+    result.should_not == described_class.new(:other_return_value)
+    result.should_not == Peeek::Call::Exception.new(:return_value)
+  end
+end
+
+describe Peeek::Call::Exception do
+  it 'inhertis Peeek::Call::Result' do
+    result = described_class.allocate
+    result.should be_a(Peeek::Call::Result)
+  end
+
+  it 'identifies as key in a hash' do
+    hash = {sample_exception => :exception}
+    hash.should     be_key(sample_exception)
+    hash.should_not be_key(sample_return_value)
+    hash.should_not be_key(described_class.new(:other_exception))
+    hash.should_not be_key(Peeek::Call::ReturnValue.new(:exception))
+  end
+end
+
+describe Peeek::Call::Exception, '#value' do
+  it 'returns the value when constructed the result' do
+    result = sample_exception
+    result.value.should == :exception
+  end
+end
+
+describe Peeek::Call::Exception, '#==' do
+  it 'verifies equivalency' do
+    result = sample_exception
+    result.should     == sample_exception
+    result.should_not == sample_return_value
+    result.should_not == described_class.new(:other_exception)
+    result.should_not == Peeek::Call::ReturnValue.new(:exception)
+  end
+end

data/spec/peeek/calls_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'peeek/calls'
+
+def sample_calls
+  Peeek::Calls.new([
+    call_stub(:return_value, :file => 'koyomi.rb',  :line =>  5, :receiver => String),
+    call_stub(:exception,    :file => 'koyomi.rb',  :line =>  7, :receiver => String),
+    call_stub(:return_value, :file => 'koyomi.rb',  :line => 11, :receiver => Numeric),
+    call_stub(:return_value, :file => 'karen.rb',   :line =>  4, :receiver => String),
+    call_stub(:return_value, :file => 'karen.rb',   :line =>  7, :receiver => Numeric),
+    call_stub(:return_value, :file => 'karen.rb',   :line => 12, :receiver => Numeric),
+    call_stub(:return_value, :file => 'tsukihi.rb', :line =>  2, :receiver => Numeric),
+    call_stub(:return_value, :file => 'tsukihi.rb', :line =>  3, :receiver => String),
+    call_stub(:return_value, :file => 'tsukihi.rb', :line => 12, :receiver => String)
+  ])
+end
+
+describe Peeek::Calls, '#in' do
+  it "returns an instance of #{described_class}" do
+    filtered_calls = sample_calls.in('koyomi.rb')
+    filtered_calls.should be_a(described_class)
+  end
+
+  it 'returns calls that corresponds to the name of the file' do
+    filtered_calls = sample_calls.in('koyomi.rb')
+    filtered_calls.should have(3).items
+  end
+
+  it 'supports Regexp' do
+    filtered_calls = sample_calls.in(/^k/)
+    filtered_calls.should have(6).items
+  end
+end
+
+describe Peeek::Calls, '#at' do
+  it "returns an instance of #{described_class}" do
+    filtered_calls = sample_calls.at(7)
+    filtered_calls.should be_a(described_class)
+  end
+
+  it 'returns calls that corresponds to the line number' do
+    filtered_calls = sample_calls.at(7)
+    filtered_calls.should have(2).items
+  end
+
+  it 'supports Range' do
+    filtered_calls = sample_calls.at(1..10)
+    filtered_calls.should have(6).items
+  end
+end
+
+describe Peeek::Calls, '#from' do
+  it "returns an instance of #{described_class}" do
+    filtered_calls = sample_calls.from(String)
+    filtered_calls.should be_a(described_class)
+  end
+
+  it 'returns calls that corresponds to the receiver' do
+    filtered_calls = sample_calls.from(String)
+    filtered_calls.should have(5).items
+  end
+end
+
+describe Peeek::Calls, '#return_values' do
+  it "returns an instance of #{described_class}" do
+    filtered_calls = sample_calls.return_values
+    filtered_calls.should be_a(described_class)
+  end
+
+  it 'returns calls that a value returned' do
+    filtered_calls = sample_calls.return_values
+    filtered_calls.should have(8).items
+  end
+end
+
+describe Peeek::Calls, '#exceptions' do
+  it "returns an instance of #{described_class}" do
+    filtered_calls = sample_calls.exceptions
+    filtered_calls.should be_a(described_class)
+  end
+
+  it 'returns calls that an exception raised' do
+    filtered_calls = sample_calls.exceptions
+    filtered_calls.should have(1).items
+  end
+end

data/spec/peeek/hook/instance_spec.rb

@@ -0,0 +1,87 @@
+require 'peeek/hook/instance'
+
+def sample_instance_linker(method_name = :%)
+  Peeek::Hook::Instance.new(String, method_name)
+end
+
+describe Peeek::Hook::Instance, '#method_prefix' do
+  it 'returns "#"' do
+    linker = sample_instance_linker
+    linker.method_prefix.should == '#'
+  end
+end
+
+describe Peeek::Hook::Instance, '#defined?' do
+  it 'is true if the method is defined in the object' do
+    linker = sample_instance_linker
+    linker.should be_defined
+  end
+
+  it 'is true if the method is defined privately in the object' do
+    linker = sample_instance_linker(:binding)
+    linker.should be_defined
+  end
+
+  it 'is false if the method is not defined in the object' do
+    linker = sample_instance_linker(:undefined_method)
+    linker.should_not be_defined
+  end
+end
+
+describe Peeek::Hook::Instance, '#link' do
+  before do
+    @original_method = String.instance_method(:%)
+    @linker = sample_instance_linker
+  end
+
+  after do
+    @linker.unlink(@original_method)
+  end
+
+  it 'gives appropriate arguments to the block when calling the method' do
+    block_args = nil
+    @linker.link { |*args| block_args = args }
+    '%s (%d)' % ['Koyomi', 18]
+    block_args[0][0].should =~ %r(spec/peeek/hook/instance_spec\.rb)
+    block_args[1].should == '%s (%d)'
+    block_args[2].should == [['Koyomi', 18]]
+  end
+
+  it 'is return value from the block as return value from the method' do
+    return_value = 'return_value'
+    @linker.link { |*args| return_value }
+    ('%s (%d)' % ['Koyomi', 18]).should equal(return_value)
+  end
+
+  it 'is exception from the block as exception from the method' do
+    @linker.link { |*args| raise 'exception' }
+    lambda { '%s (%d)' % ['Koyomi', 18] }.should raise_error('exception')
+  end
+
+  it 'returns the original method' do
+    @linker.link { }.should == @original_method
+  end
+
+  it 'raises ArgumentError if a block not given' do
+    lambda { @linker.link }.should raise_error(ArgumentError, 'block not supplied')
+  end
+end
+
+describe Peeek::Hook::Instance, '#unlink' do
+  before do
+    @original_method = String.instance_method(:%)
+    @linker = sample_instance_linker
+    @linker.link { fail }
+  end
+
+  it 'defines method with the original method' do
+    call = lambda { '%s (%d)' % ['Koyomi', 18] }
+
+    # assert
+    call.should raise_error
+
+    @linker.unlink(@original_method)
+    call.should_not raise_error
+    call[].should == 'Koyomi (18)'
+  end
+end

data/spec/peeek/hook/linker_spec.rb

@@ -0,0 +1,15 @@
+require 'peeek/hook/linker'
+
+describe Peeek::Hook::Linker, '.classes' do
+  before do
+    @class = Class.new(described_class)
+  end
+
+  after do
+    described_class.classes.delete(@class)
+  end
+
+  it "returns classes that inherited #{described_class}" do
+    described_class.classes.should be_include(@class)
+  end
+end