markevans-method_call_recorder 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Mark Evans
+
+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/README.markdown

@@ -0,0 +1,26 @@
+Method call recorder
+===================
+A method call recorder is an object on which you can call any method, with any arguments (and continue doing so on child objects).
+
+    rec = MethodCallRecorder.new
+    rec[:this].is(:a, 'nice')[:little, :object].isnt.it?  # This does very little, but it works!
+    
+You can then play methods back on other objects.
+
+    rec[1].upcase   # first record the method chain
+    rec._play(['hello','there']) # => 'THERE'
+    
+You can also inspect the method chain if you wish (shows all methods called including arguments). This is an array of `MethodCall` objects.
+Using the last example:
+
+    method_call = rec._method_chain.first
+    method_call.method  #  :[] (a symbol representing the method call)
+    method_call.args    #  [1] (an array of the args)
+
+Install
+-------
+Install from github gems in usual way
+
+Copyright
+--------
+Copyright (c) 2009 Mark Evans. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "method_call_recorder"
+    gem.summary = "An object on which you can call anything, where nothing happens, but the whole method chain is recorded"
+    gem.email = "mark@new-bamboo.co.uk"
+    gem.homepage = "http://github.com/markevans/method_call_recorder"
+    gem.authors = ["Mark Evans"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "method_call_recorder #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/method_call_recorder/method_call.rb

@@ -0,0 +1,70 @@
+class MethodCall
+
+
+  def initialize(meth, *args, &blk)
+    @method, @args = meth, args
+    @block = blk
+  end
+
+  attr_reader :method, :args, :block
+
+  def call_on(obj)
+    obj.send(method, *args)
+  end
+
+  def to_a
+    [method, *args]
+  end
+
+  def setter?
+    !!(method.to_s =~ /=$/)
+  end
+
+  def getter?
+    !setter?
+  end
+
+  def to_setter(value)
+    new_method_call = self.deep_dup
+    if setter?
+      new_method_call.args[-1] = value
+    else
+      new_method_call.args << value
+      new_method_call.method = "#{new_method_call.method}=".to_sym
+    end
+    new_method_call
+  end
+
+  def type
+    case method.to_s
+    when '[]'  then (args.first.is_a?(Fixnum) ? :array_reader : :hash_reader)
+    when '[]=' then (args.first.is_a?(Fixnum) ? :array_writer : :hash_writer)
+    when /\=$/ then :attr_writer
+    else :attr_reader
+    end
+  end
+
+  def guess_receiver_type
+    case type
+    when :array_reader, :array_writer then Array
+    when :hash_reader,  :hash_writer then Hash
+    end
+  end
+
+  def ==(other)
+    self.method == other.method && self.args == other.args
+  end
+
+  def deep_dup
+    self.class.new(method, *args, &block)
+  end
+
+  def to_s
+    to_a.to_s
+  end
+
+  protected
+
+  attr_writer :method
+
+end

data/lib/method_call_recorder/method_call_recorder.rb

@@ -0,0 +1,58 @@
+class MethodCallRecorder
+
+  def _play(object, &blk)
+    i = 0
+    _method_chain.inject(object) do |obj, method_call|
+      i += 1
+      yield(obj, method_call, _method_chain[i]) if block_given?
+      method_call.call_on(obj)
+    end
+  end
+
+  def _first_method
+    _method_chain.first
+  end
+  
+  def _empty?
+    _method_chain.empty?
+  end
+
+  def to_s
+    _method_chain.inspect
+  end
+
+  def _method_chain
+    @_method_chain ||= []
+  end
+  
+  def _to_setter(value)
+    new_rec = self.dup
+    new_rec._method_chain = self._method_chain.dup
+    new_rec._method_chain[-1] = self._method_chain[-1].to_setter(value)
+    new_rec
+  end
+  
+  def _reset!
+    _method_chain = []
+  end
+  
+  def _select(meth, args=nil)
+    _method_chain.select do |method_call|
+      selected = (method_call.method == meth)
+      selected &&= (method_call.args == args) if args
+      selected
+    end
+  end
+
+  protected
+  
+  attr_writer :_method_chain
+
+  private
+
+  def method_missing(meth, *args)
+    _method_chain << MethodCall.new(meth, *args)
+    self
+  end
+
+end

data/lib/method_call_recorder.rb

@@ -0,0 +1,3 @@
+%w{method_call method_call_recorder}.each do |file|
+  require File.dirname(__FILE__)+'/method_call_recorder/'+file
+end

data/method_call_recorder.gemspec

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{method_call_recorder}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mark Evans"]
+  s.date = %q{2009-07-04}
+  s.email = %q{mark@new-bamboo.co.uk}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/method_call_recorder.rb",
+     "lib/method_call_recorder/method_call.rb",
+     "lib/method_call_recorder/method_call_recorder.rb",
+     "method_call_recorder.gemspec",
+     "spec/method_call_recorder_spec.rb",
+     "spec/method_call_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/markevans/method_call_recorder}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{An object on which you can call anything, where nothing happens, but the whole method chain is recorded}
+  s.test_files = [
+    "spec/method_call_recorder_spec.rb",
+     "spec/method_call_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/method_call_recorder_spec.rb

@@ -0,0 +1,125 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+def stub_method_call(*args)
+  method_call = mock('method_call')
+  MethodCall.stub!(:new).with(*args).and_return method_call
+  method_call
+end
+
+describe MethodCallRecorder do
+
+  before(:each) do
+    @rec = MethodCallRecorder.new
+  end
+
+  it "should allow any combination of chained methods on it" do
+    lambda do
+      MethodCallRecorder.new.egg[23]['fish'].another = 5
+      MethodCallRecorder.new[:twenty].what.the / 8 * 4 + 1
+    end.should_not raise_error
+  end
+
+  it "should save methods called on it in it's 'method chain'" do
+    mc1 = stub_method_call(:this, :should)
+    mc2 = stub_method_call(:[], 'be')
+    mc3 = stub_method_call(:saved)
+    @rec.this(:should)['be'].saved
+    @rec._method_chain.should == [mc1, mc2, mc3]
+  end
+
+  it "should be able to play back its method chain on another object" do
+    inner = mock('inner', :duck => 'hello')
+    struct = mock('struct', :fish => inner)
+    obj = { :a => [struct, 2] }
+    @rec[:a][0].fish.duck
+    @rec._play(obj).should == 'hello'
+  end
+
+  it "should just return the object on play if its method chain is empty" do
+    obj = Object.new
+    @rec._play(obj).should == obj
+  end
+
+  it "should record append to the method chain if you record twice" do
+    mc1 = stub_method_call(:once)
+    mc2 = stub_method_call(:twice)
+    @rec.once
+    @rec._method_chain.should == [mc1]
+    @rec.twice
+    @rec._method_chain.should == [mc1, mc2]
+  end
+
+  it "should allow resetting the method chain" do
+    mc1 = stub_method_call(:once)
+    mc2 = stub_method_call(:twice)
+    @rec.once
+    @rec._method_chain.should == [mc1]
+    @rec._reset!
+    @rec.twice
+    @rec._method_chain.should == [mc1, mc2]
+  end
+
+  it "should yield the current sub object, and the next two methods to be called as it plays back" do
+    mc1 = MethodCall.new(:[], :hello)
+    mc2 = MethodCall.new(:[], 2)
+    mc3 = MethodCall.new(:eggy_bread)
+    str = 'yes'
+    def str.eggy_bread; 'egg'; end
+    @rec[:hello][2].eggy_bread
+    yielded_values = []
+    @rec._play({:hello => ['no','and',str]}) do |obj, method_call, next_method_call|
+      yielded_values << [obj, method_call, next_method_call]
+    end
+    yielded_values.should == [
+      [ {:hello => ['no','and',str]}, mc1, mc2 ],
+      [ ['no','and',str],             mc2, mc3 ],
+      [ str,                          mc3, nil ]
+    ]
+  end
+
+  it "should return the first method called on it" do
+    @rec.hello.how.are['you']
+    @rec._first_method.should == MethodCall.new(:hello)
+  end
+
+  it "should return itself" do
+    @rec.hello[4].this(:is).now('innit').should == @rec
+  end
+  
+  it "should return a clone of itself with the last method as a setter" do
+    mc1 = MethodCall.new(:[], :hello)
+    mc2 = MethodCall.new(:there)
+    mc3 = MethodCall.new(:there=, 4)
+    @rec[:hello].there
+    other_rec = @rec._to_setter(4)
+    @rec._method_chain.should      == [mc1, mc2]
+    other_rec._method_chain.should == [mc1, mc3]
+  end
+
+  it "should say if empty" do
+    @rec._empty?.should be_true
+  end
+  
+  it "should say if not empty" do
+    @rec.hello._empty?.should be_false
+  end
+  
+  describe "selecting methods" do
+    before :each do
+      @rec.this[:is, 2].a(3, 'go').metho[:call].a('yo')
+      @m1, @m2, @m3, @m4, @m5, @m6 = @rec._method_chain
+    end
+    
+    it "should select matching only on method" do
+      @rec._select(:[]).should == [@m2, @m5]
+      @rec._select(:a).should == [@m3, @m6]
+    end
+    
+    it "should select matching on method and args" do
+      @rec._select(:[], [:call]).should == [@m5]
+      @rec._select(:a, ['yo']).should == [@m6]
+    end
+
+  end
+
+end

data/spec/method_call_spec.rb

@@ -0,0 +1,161 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe MethodCall do
+  
+  before(:each) do
+    @method_call = MethodCall.new(:hello, 4, 'yo')
+  end
+  
+  it "should return the method name" do
+    
+    @method_call.method.should == :hello
+  end
+  it "should return the args" do
+    @method_call.args.should == [4, 'yo']
+  end
+  it "should return the block as nil if not given" do
+    @method_call.block.should be_nil
+  end
+  it "should return the block if given" do
+    method_call = MethodCall.new(:hi){ |doobie| puts doobie }
+    method_call.block.should be_kind_of(Proc)
+  end
+  
+  describe "call_on" do
+    it "should call the method on the passed in object and return the value" do
+      string = 'yoh washup'
+      method_call = MethodCall.new(:gsub, 'h', 'e')
+      method_call.call_on(string).should == 'yoe waseup'
+    end
+  end
+  
+  describe "to array" do
+    it "should return the method and args as an array" do
+      MethodCall.new(:egg, 'cheese', 5).to_a.should == [:egg, 'cheese', 5]
+    end
+  end
+  
+  describe "setter?" do
+    it "should return true for a setter" do
+      MethodCall.new(:doobie=, '4').setter?.should be_true
+      MethodCall.new(:[]=, 2, 3).setter?.should be_true
+    end
+    it "should return false for a getter" do
+      MethodCall.new(:doobie, '4').setter?.should be_false
+      MethodCall.new(:[], 2, 3).setter?.should be_false
+    end
+  end
+  
+  describe "getter?" do
+    it "should be false if setter is true" do
+      @method_call.should_receive(:setter?).and_return true
+      @method_call.getter?.should be_false
+    end
+    it "should be true if setter is false" do
+      @method_call.should_receive(:setter?).and_return false
+      @method_call.getter?.should be_true
+    end
+  end
+  
+  describe "duplication" do
+    before(:each) do
+      @mc1 = MethodCall.new(:[], 3)
+      @mc2 = @mc1.deep_dup
+    end
+    it "should be able to duplicate itself" do
+      @mc2.should be_instance_of(MethodCall)
+    end
+    it "should deep clone its method" do
+      @mc2.send(:method=, :hi)
+      @mc2.method.should == :hi # Just to check
+      @mc1.method.should == :[] 
+    end
+    it "should deep clone its args" do
+      @mc2.args << :gog
+      @mc2.args.should == [3, :gog] # Just to check
+      @mc1.args.should == [3]
+    end
+  end
+  
+  describe "making methods into setters" do
+
+    it "should turn [] into a setter" do
+      MethodCall.new(:[], 3).to_setter('hello').to_a.should == [:[]=, 3, 'hello']
+    end
+
+    it "should leave []= as it is but assign new value" do
+      MethodCall.new(:[]=, 3, 5).to_setter('hello').to_a.should == [:[]=, 3, 'hello']
+    end
+
+    it "should turn an arbitrary method call into a setter by adding the value at the end of the args" do
+      MethodCall.new(:hello, 'there').to_setter(65).to_a.should == [:hello=, 'there', 65]
+    end
+
+    it "should not change an arbitrary method which is already a setter but assign a new value" do
+      MethodCall.new(:hello=, 'there').to_setter(65).to_a.should == [:hello=, 65]
+    end
+    
+    it "should not change itself" do
+      method_call = MethodCall.new(:[], 3)
+      setter = method_call.to_setter('yo')
+      method_call.to_a.should == [:[], 3]
+    end
+
+  end
+  
+  describe "getting the type" do
+    it "should detect hash readers" do
+      MethodCall.new(:[], 'there').type.should == :hash_reader
+    end
+    it "should detect hash writers" do
+      MethodCall.new(:[]=, 'there', 4).type.should == :hash_writer
+    end
+    it "should detect array readers" do
+      MethodCall.new(:[], 7).type.should == :array_reader
+    end
+    it "should detect array writer" do
+      MethodCall.new(:[]=, 3, 5).type.should == :array_writer
+    end
+    it "should detect getters" do
+      MethodCall.new(:undre).type.should == :attr_reader
+    end
+    it "should detect setters" do
+      MethodCall.new(:bob=, 'there').type.should == :attr_writer
+    end
+    
+  end
+  
+  describe "comparing with other method calls" do
+    it "should return as equal if both have same method and args" do
+      MethodCall.new(:yes, 'sadf', :ue, 4).should == MethodCall.new(:yes, 'sadf', :ue, 4)
+    end
+    it "should return as not equal if same method but different args" do
+      MethodCall.new(:yes, 'sadf', 4).should_not == MethodCall.new(:yes, 'sadf', :ue, 4)
+    end
+    it "should return as not equal if same args but different method" do
+      MethodCall.new(:yes, 'sadf', :ue, 4).should_not == MethodCall.new(:no, 'sadf', :ue, 4)
+    end
+    it "should return as not equal if different method and args" do
+      MethodCall.new(:yes, 'sadf', :ue, 4).should_not == MethodCall.new(:no, 3, 5, 'sdf')
+    end
+  end
+  
+  describe "guessing receiver type for square brackets calls" do
+
+    [:hello, 'hello', 4.3].each do |key|
+      it "should return Hash if key is #{key.inspect}" do
+        MethodCall.new(:[],:hello).guess_receiver_type.should == Hash
+      end
+    end
+
+    it "should return Array if key is an integer" do
+      MethodCall.new(:[],4).guess_receiver_type.should == Array
+    end
+    
+    it "should return nil if it can't guess" do
+      MethodCall.new(:yo_man, 'diggerdy').guess_receiver_type.should be_nil
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'spec'
+require File.dirname(__FILE__)+'/../lib/method_call_recorder'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: markevans-method_call_recorder
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mark Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mark@new-bamboo.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- lib/method_call_recorder.rb
+- lib/method_call_recorder/method_call.rb
+- lib/method_call_recorder/method_call_recorder.rb
+- method_call_recorder.gemspec
+- spec/method_call_recorder_spec.rb
+- spec/method_call_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/markevans/method_call_recorder
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An object on which you can call anything, where nothing happens, but the whole method chain is recorded
+test_files: 
+- spec/method_call_recorder_spec.rb
+- spec/method_call_spec.rb
+- spec/spec_helper.rb