cb 1.0.1

data/README

@@ -0,0 +1,42 @@
+Simple native Callback object for Ruby MRI
+  (c) 2009 Lourens Naudé (methodmissing), James Tucker (raggi) and coderrr
+ 
+  http://github.com/methodmissing/cb
+
+This library works with Ruby 1.8 and 1.9 and is a more efficient
+implementation of the following Ruby code :
+
+  class RubyCallback
+    def initialize(object = nil, method = :call, &b)
+      @object, @method = object, method
+      @object ||= b
+    end
+  
+    def call(*args)
+      @object.__send__(@method, *args)
+    end
+  end
+
+  module Kernel
+    private
+    def RubyCallback(object = nil, method = :call, &b)
+      RubyCallback.new(object, method, &b)
+    end
+  end
+
+Concept, ideas and API design James's - any pointers for better GC integration much appreciated.
+
+Examples :
+
+  'hai'.callback(:gsub).call('h', 'b') #=> 'bai'
+  Callback( 'bai', :to_s ).call #=> 'hai'
+  Callback{ 'hai' }.call #=> 'hai'
+  Callback( 'bai', :gsub ).call( 'b', 'h' ) #=> 'hai'
+
+To run the test suite:
+
+  rake
+
+To run the benchmarks:
+
+  rake bench

data/Rakefile

@@ -0,0 +1,171 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+require 'rake/clean'
+
+def spec(file = Dir['*.gemspec'].first)
+  @spec ||=
+  begin
+    require 'rubygems/specification'
+    Thread.abort_on_exception = true
+    data = File.read(file)
+    spec = nil
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+    spec.instance_variable_set(:@filename, file)
+    def spec.filename; @filename; end
+    spec
+  end
+end
+
+def manifest; @manifest ||= `git ls-files`.split("\n").reject{|s|s=~/\.gemspec$|\.gitignore$/}; end
+
+@gem_package_task_type = begin
+  require 'rubygems/package_task'
+  Gem::PackageTask
+rescue LoadError
+  require 'rake/gempackagetask'
+  Rake::GemPackageTask
+end
+def gem_task; @gem_task ||= @gem_package_task_type.new(spec); end
+gem_task.define
+Rake::Task[:clobber].enhance [:clobber_package]
+
+rdoc_task_type = begin
+  require 'rdoc/task'
+  RDoc::Task
+rescue LoadError
+  require 'rake/rdoctask'
+  Rake::RDocTask
+end
+df = begin; require 'rdoc/generator/darkfish'; true; rescue LoadError; end
+rdtask = rdoc_task_type.new do |rd|
+  rd.title = spec.name
+  rd.main = spec.extra_rdoc_files.first
+  lib_rexp = spec.require_paths.map { |p| Regexp.escape p }.join('|')
+  rd.rdoc_files.include(*manifest.grep(/^(?:#{lib_rexp})/))
+  rd.rdoc_files.include(*spec.extra_rdoc_files)
+  rd.template = 'darkfish' if df
+end
+
+Rake::Task[:clobber].enhance [:clobber_rdoc]
+
+desc 'Generate and open documentation'
+task :docs => :rdoc do
+  path = rdtask.send :rdoc_target
+  case RUBY_PLATFORM
+  when /darwin/       ; sh "open #{path}"
+  when /mswin|mingw/  ; sh "start #{path}"
+  else 
+    sh "firefox #{path}"
+  end
+end
+
+desc "Regenerate gemspec"
+task :gemspec => spec.filename
+
+task spec.filename do
+  spec.files = manifest
+  spec.test_files = FileList['{test,spec}/**/{test,spec}_*.rb']
+  open(spec.filename, 'w') { |w| w.write spec.to_ruby }
+end
+
+desc "Bump version from #{spec.version} to #{spec.version.to_s.succ}"
+task :bump do
+  spec.version = spec.version.to_s.succ
+end
+
+desc "Tag version #{spec.version}"
+task :tag do
+  tagged = Dir.new('.git/refs/tags').entries.include? spec.version.to_s
+  if tagged
+    warn "Tag #{spec.version} already exists"
+  else
+    # TODO release message in tag message
+    sh "git tag #{spec.version}"
+  end
+end
+
+if spec.rubyforge_project
+  require 'yaml'
+  require 'rake/contrib/sshpublisher'
+  desc "Publish rdoc to rubyforge"
+  task :publish => rdtask.name do
+    rf_cfg = File.expand_path '~/.rubyforge/user-config.yml'
+    host = "#{YAML.load_file(rf_cfg)['username']}@rubyforge.org"
+    remote_dir = "/var/www/gforge-projects/#{spec.rubyforge_project}/#{spec.name}/"
+    Rake::SshDirPublisher.new(host, remote_dir, rdtask.rdoc_dir).upload
+  end
+
+  desc "Release #{gem_task.gem_file} to rubyforge"
+  task :release => [:tag, :gem, :publish] do |t|
+    sh "rubyforge add_release #{spec.rubyforge_project} #{spec.name} #{spec.version} #{gem_task.package_dir}/#{gem_task.gem_file}"
+  end
+else
+  warn "Cannot release to rubyforge - no rubyforge_project in gemspec"
+end
+
+CB_ROOT = 'ext/mri_callback'
+
+desc 'Default: test'
+task :default => :test
+
+desc 'Run callback tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << CB_ROOT
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+end
+task :test
+
+namespace :build do
+  file "#{CB_ROOT}/mri_callback.c"
+  file "#{CB_ROOT}/extconf.rb"
+  file "#{CB_ROOT}/Makefile" => %W(#{CB_ROOT}/mri_callback.c #{CB_ROOT}/extconf.rb) do
+  Dir.chdir(CB_ROOT) do
+    ruby 'extconf.rb'
+  end
+end
+
+desc "generate makefile"
+task :makefile => %W(#{CB_ROOT}/Makefile #{CB_ROOT}/mri_callback.c)
+
+dlext = Config::CONFIG['DLEXT']
+file "#{CB_ROOT}/mri_callback.#{dlext}" => %W(#{CB_ROOT}/Makefile #{CB_ROOT}/mri_callback.c) do
+Dir.chdir(CB_ROOT) do
+  sh 'make' # TODO - is there a config for which make somewhere?
+end
+end
+
+desc "compile callback extension"
+task :compile => "#{CB_ROOT}/mri_callback.#{dlext}"
+
+task :clean do
+  Dir.chdir(CB_ROOT) do
+    sh 'make clean'
+  end if File.exists?("#{CB_ROOT}/Makefile")
+end
+
+CLEAN.include("#{CB_ROOT}/Makefile")
+CLEAN.include("#{CB_ROOT}/mri_callback.#{dlext}")
+end
+
+task :clean => %w(build:clean)
+
+desc "compile"
+task :build => %w(build:compile)
+
+task :install do |t|
+  Dir.chdir(CB_ROOT) do
+    sh 'sudo make install'
+  end
+end
+
+desc "clean build install"
+task :setup => %w(clean build install)
+
+desc "run benchmarks"
+task :bench do |t|
+  ruby "-Ilib:ext/mri_callback:bench", "bench/bench.rb"
+  puts
+  ruby "-Ilib:ext/mri_callback:bench", "bench/raggi_bench.rb"
+end
+task :bench

data/bench/bench.rb

@@ -0,0 +1,22 @@
+require "benchmark"
+require "callback"
+require "pure_ruby_cb"
+
+class Object
+  public :method
+end
+
+def meth
+  'hai'
+end
+
+TESTS = 10_000
+Benchmark.bmbm do |results|
+  results.report("Method object:") { TESTS.times { method(:meth).call } }
+  results.report("Callback{ 'hai' }.call") { TESTS.times { Callback{ 'hai' }.call } }  
+  results.report("RubyCallback{ 'hai' }.call") { TESTS.times { RubyCallback{ 'hai' }.call } }
+  results.report("Callback( 'bai', :to_s ).call") { TESTS.times { Callback( 'bai', :to_s ).call } }  
+  results.report("RubyCallback( 'bai', :to_s ).call") { TESTS.times { RubyCallback( 'bai', :to_s ).call } }  
+  results.report("Callback( 'bai', :gsub ).call( 'b', 'h' )") { TESTS.times { Callback( 'bai', :gsub ).call( 'b', 'h' ) } }  
+  results.report("RubyCallback( 'bai', :gsub ).call( 'b', 'h' )") { TESTS.times { RubyCallback( 'bai', :gsub).call( 'b', 'h' ) } }
+end

data/bench/pure_ruby_cb.rb

@@ -0,0 +1,17 @@
+class RubyCallback
+  def initialize(object = nil, method = :call, &b)
+    @object, @method = object, method
+    @object ||= b
+  end
+  
+  def call(*args)
+    @object.__send__(@method, *args)
+  end
+end
+
+module Kernel
+  private
+  def RubyCallback(object = nil, method = :call, &b)
+    RubyCallback.new(object, method, &b)
+  end
+end

data/bench/raggi_bench.rb

@@ -0,0 +1,24 @@
+require "benchmark"
+require "callback"
+require "pure_ruby_cb"
+
+@s = 'foo'
+def me; @s.to_s; end
+ld = lambda { @s.to_s }
+cb = Callback &ld
+c2 = Callback( @s, :to_s )
+rb = RubyCallback { @s.to_s }
+farm = @s.callback(:to_s)
+meth = @s.send(:method, :to_s)
+
+tests = 100_000
+puts "# Calling"
+Benchmark.bmbm do |results|
+  results.report("method invoked:") { tests.times { me } }
+  results.report("ruby method obj:") { tests.times { meth.call } }
+  results.report("object native callback:") { tests.times { farm.call } }
+  results.report("callback native:") { tests.times { c2.call } }
+  results.report("callback block:") { tests.times { cb.call } }
+  results.report("pure ruby callback:") { tests.times { rb.call } }
+  results.report("lambda:") { tests.times { ld.call } }
+end

data/ext/mri_callback/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config('mri_callback')
+
+create_makefile('mri_callback')

data/ext/mri_callback/mri_callback.c

@@ -0,0 +1,85 @@
+#include "ruby.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(obj) RSTRING(obj)->ptr
+#endif
+
+typedef struct {
+    VALUE object;
+	ID method;
+} RCallback;
+
+#define GetCallbackStruct(obj)	(Check_Type(obj, T_DATA), (RCallback*)DATA_PTR(obj))
+
+VALUE rb_cCallback;
+static ID id_call;
+
+static void mark_mri_callback(RCallback* cb)
+{
+    rb_gc_mark(cb->object);
+}
+
+static void free_mri_callback(RCallback* cb)
+{
+    xfree(cb);
+}
+
+static VALUE callback_alloc _((VALUE));
+static VALUE
+callback_alloc( VALUE klass )
+{
+	VALUE cb;
+	RCallback* cbs;
+	cb = Data_Make_Struct(klass, RCallback, mark_mri_callback, free_mri_callback, cbs);
+    cbs->object = Qnil;
+	cbs->method = 0;
+	
+    return cb;
+}
+
+static VALUE
+rb_mri_callback_new()
+{
+    return callback_alloc(rb_cCallback);
+}
+
+static VALUE rb_mri_callback_initialize( int argc, VALUE *argv, VALUE cb )
+{
+	VALUE object;
+	VALUE method;
+	ID meth;
+	RCallback* cbs = GetCallbackStruct(cb);
+	 
+	if (rb_block_given_p()) {
+	  if (argc == 1) rb_raise(rb_eArgError, "wrong number of arguments");
+	    cbs->object = rb_block_proc();
+	    cbs->method = id_call;
+    }else {
+	    rb_scan_args(argc, argv, "02", &object, &method);
+	    cbs->object = object;
+	    meth = rb_to_id(method);
+	    if (!rb_respond_to(object,meth)) rb_raise(rb_eArgError, "object does not respond to %s", RSTRING_PTR(rb_obj_as_string(method)));
+	    cbs->method = meth;
+    }
+
+	OBJ_FREEZE(cb);
+	return cb;
+}
+
+static VALUE rb_mri_callback_call( VALUE cb, VALUE args )
+{
+	RCallback* cbs = GetCallbackStruct(cb);
+	return rb_apply(cbs->object, cbs->method, args); 
+}
+
+void
+Init_mri_callback()
+{
+    id_call = rb_intern("call");
+ 
+    rb_cCallback  = rb_define_class("Callback", rb_cObject);
+    rb_define_alloc_func(rb_cCallback, callback_alloc);
+    
+    rb_define_method(rb_cCallback,"initialize", rb_mri_callback_initialize, -1);
+    rb_define_method(rb_cCallback,"call", rb_mri_callback_call, -2);
+}	

data/lib/cb.rb

@@ -0,0 +1,72 @@
+begin
+  require 'mri_callback'
+rescue LoadError
+end
+
+# A simple __send__ based callback implementation, simply Object Orients
+# something equivalent to:
+#
+#  lambda { |*args| object.__send__ method, *args }
+class Callback
+  class << self; attr_reader :extension_loaded; end
+
+  begin
+    cb = new(self, :instance_variable_set)
+    cb.respond_to?(:call) && cb.call(:@extension_loaded, true)
+  rescue ArgumentError
+    @extension_loaded = false
+  end
+
+  unless @extension_loaded
+    warn "Using pure ruby Callback"
+    def initialize(object, method)
+      @object, @method = object, method
+    end
+
+    def call(*args)
+      @object.__send__(@method, *args)
+    end
+  end
+end
+
+# A quick monkey patch providing a public equivalent of the #method private
+# method aliased to #callback. This is intended for use as a persistent
+# callback object. It should be noted that using Method objects under MRI has
+# in the past lead to user induced leaks. One must be careful when using it.
+class Object
+  alias callback method
+
+  # Allow users to call object.callback(:method_name) to grab a Method object.
+  public :callback
+end
+
+# Utility method for coercing arguments to an object that responds to #call
+# Accepts an object and a method name to send to, or a block, or an object
+# that responds to call.
+#
+#  cb = Callback{ |msg| puts(msg) }
+#  cb.call('hello world')
+#
+#  cb = Callback(Object, :puts)
+#  cb.call('hello world')
+#
+#  cb = Callback(proc{ |msg| puts(msg) })
+#  cb.call('hello world')
+module Kernel
+  def Callback(object = nil, method = nil, &blk)
+    if object && method
+      Callback.new(object, method)
+    else
+      if object.respond_to? :call
+        object
+      else
+        if object && blk || blk.nil?
+          raise(ArgumentError, "Callback required an object responding to #call or an object and a method, or a block")
+        else
+          blk
+        end
+      end
+    end
+  end
+  private :Callback
+end

data/test/test_cb.rb

@@ -0,0 +1,78 @@
+require "test/unit"
+require "cb"
+
+class TestCallbackPureRuby < Test::Unit::TestCase
+  def test_Callback_with_lambda
+    ran = false
+    l = lambda { ran = true }
+    Callback(l).call
+    assert ran
+  end
+
+  def cb
+    @ran = true
+  end
+
+  def test_Callback_with_object_and_method
+    @ran = false
+    Callback(self, :cb).call
+    assert @ran
+  end
+
+  def test_Callback_with_block
+    ran = false
+    Callback { ran = true }.call
+    assert ran
+  end
+
+  def test_Callback_with_no_arguments
+    assert_raises(ArgumentError) do
+      Callback()
+    end
+  end
+
+  def test_Object_callback
+    @ran = false
+    self.callback(:cb).call
+    assert @ran
+  end
+
+  def test_block
+    cb = Callback{ 'hai' }
+    assert_equal 'hai', cb.call
+  end
+
+  def test_init_object_call_with_no_args
+    cb = Callback( 'bai', :to_s ) 
+    assert_equal 'bai', cb.call
+  end
+
+  def test_init_object_call_with_args
+    cb = Callback( 'bai', :gsub )
+    assert_equal 'hai', cb.call( 'b', 'h' )
+  end
+
+  def test_many_calls
+    cb = Callback { :foo }
+    100_000.times { cb.call }
+  end  
+
+  def test_arguments
+    assert_raises ArgumentError do
+      Callback( 'hai' ){}
+    end
+  end
+
+  def test_farmed_from_object
+    cb = 'hai'.callback(:to_s)
+    assert_equal 'hai', cb.call
+    ocb = 'bai'.callback(:gsub)
+    assert_equal 'hai', ocb.call('b', 'h')
+  end  
+
+  def test_invalid_method
+    assert_raises NameError do
+      'str'.callback(:undefined)
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: cb
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- "Lourens Naud\xC3\xA9 (methodmissing)"
+- James Tucker (raggi)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-22 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Simple native Callback object for Ruby MRI (1.8.{6,7} and 1.9.2)
+email: lourens@methodmissing.com
+executables: []
+
+extensions: 
+- ext/mri_callback/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- bench/bench.rb
+- bench/pure_ruby_cb.rb
+- bench/raggi_bench.rb
+- ext/mri_callback/extconf.rb
+- ext/mri_callback/mri_callback.c
+- lib/cb.rb
+- test/test_cb.rb
+has_rdoc: true
+homepage: http://github.com/methodmissing/cb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Native MRI callback
+test_files: 
+- test/test_cb.rb