callwith 0.0.1

data/README.md

@@ -0,0 +1,96 @@
+callwith
+========
+
+Synopsis
+--------
+
+`Object#callwith` is like `instance_eval`, but can still delegate back to the
+original object if a method is not found.  Also unlike `instance_eval`,
+all instance variables accessed within the block reference the original
+self object.
+
+    gem install callwith
+
+    callwith(obj) do
+      # stuff
+    end
+
+(this method was originally called `with` when it was part of
+RubyTreasures, but has been renamed to `callwith` to avoid conflict with
+the `with` gem).
+
+Background
+----------
+
+One common problem with using `instance_eval` as a tool for brevity is
+that it can easily become unclear which object is `self`.  For example,
+the Tk library that comes with Ruby makes heavy use of `instance_eval`:
+
+    class MyApplication
+      def initialize
+        @root = TkRoot.new
+        TkFrame.new do
+          TkButton.new do
+            text "Ok"
+
+            # The action() method will never be called, because this
+            # block was called with instance_eval, so `self` is not
+            # the MyApplication instance.
+            command proc { action() }
+
+            pack
+          end
+          pack
+        end
+      end
+
+      def action()
+        puts "Hello, world"
+      end
+    end
+
+The `callwith` method will delegate method calls to the passed object;
+however, if the passed object does not have such a method, `callwith` will
+fall back onto calling on `self`.  For example:
+
+    class HelloWorld
+      def initialize
+        @hello_count = 0
+      end
+
+      def hello(file)
+        callwith(file) do
+          write("Hello world") # writes "Hello world" to file
+          increment()          # calls increment on the HelloWorld instance
+        end
+      end
+
+      def increment
+        @hello_count += 1
+      end
+    end
+
+All accessed instance variables are in the `self` object, so we could
+have written hello() like this:
+
+    def hello(file)
+      callwith(file) do
+        write("Hello world")
+        increment()
+      end
+    end
+
+The `callwith` method can also iterate over multiple objects, e.g.:
+
+    def hello(*files)
+      callwith(*files) do
+        write("Hello world")
+        increment()
+      end
+    end
+
+License
+-------
+
+License is the MIT License (http://www.opensource.org/licenses/mit-license.html) 
+

data/ext/callwith_ext.c

@@ -0,0 +1,71 @@
+#include <ruby.h>
+#include <st.h>
+
+static VALUE rb_cCallWith = Qnil;
+
+static VALUE callwith_s_create(VALUE klass, VALUE obj, VALUE self_obj)
+{
+  /* Create a new CallWith object, bypassing the usual object creation,
+   * because the CallWith class is not a normal class. */
+  NEWOBJ(with, struct RObject);
+  OBJSETUP(with, klass, T_OBJECT);
+  VALUE self = (VALUE)with;
+
+  /* Place our delegate objects into the singleton class so we can
+   * access them later */
+  VALUE s = rb_singleton_class(self);
+  rb_iv_set(s, "__with_obj__", obj);
+  rb_iv_set(s, "__with_self_obj__", self_obj);
+
+  /* Copy the pointer to the instance variable table from self_obj.  As
+   * long as we hold a reference to self_obj, this pointer should be
+   * valid. */
+  struct RBasic basic = *(RBASIC(self));
+  *(ROBJECT(self)) = *(ROBJECT(self_obj));
+  *(RBASIC(self)) = basic;
+
+  return self;
+}
+
+static VALUE callwith_obj(VALUE self)
+{
+  return rb_iv_get(rb_singleton_class(self), "__with_obj__");
+}
+
+static VALUE callwith_self_obj(VALUE self)
+{
+  return rb_iv_get(rb_singleton_class(self), "__with_self_obj__");
+}
+
+static VALUE callwith_cleanup(VALUE self)
+{
+  /* We don't want to keep the ivar table pointer around indefinitely,
+   * because if we do, the GC will free the ivar table, which is
+   * undesirable, since the original object still references it.  So we
+   * set the ivar table back to something that won't get freed, instead.
+   */
+
+  NEWOBJ(dummy, struct RObject);
+  OBJSETUP(dummy, rb_cCallWith, T_OBJECT);
+
+  struct RBasic basic = *(RBASIC(self));
+  *(ROBJECT(self)) = *(ROBJECT(dummy));
+  *(RBASIC(self)) = basic;
+}
+
+void Init_with_ext()
+{
+  VALUE super = rb_class_boot(0);
+  rb_cCallWith = rb_class_boot(super);
+  rb_name_class(rb_cCallWith, rb_intern("CallWith"));
+  rb_const_set(rb_cObject, rb_intern("CallWith"), rb_cCallWith);
+  rb_global_variable(&rb_cCallWith);
+
+  rb_undef_alloc_func(rb_cCallWith);
+  rb_define_singleton_method(rb_cCallWith, "create", callwith_s_create, 2);
+  rb_define_method(rb_cCallWith, "__instance_eval__", rb_obj_instance_eval, -1);
+  rb_define_method(rb_cCallWith, "__with__obj__", callwith_obj, 0);
+  rb_define_method(rb_cCallWith, "__with__self_obj__", callwith_self_obj, 0);
+  rb_define_method(rb_cCallWith, "__with__cleanup__", callwith_cleanup, 0);
+}
+

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+create_makefile('callwith_ext')
+

data/lib/callwith.rb

@@ -0,0 +1,35 @@
+require 'with_ext'
+
+# Iterate over the given objects and delegate all instance method calls
+# in the block to the object.  Instance variables accessed from inside
+# the block are delegated to the receiver of the method.  Returns the
+# result of the last expression evaluated.
+#
+# Example:
+#
+#     callwith(file1, file2) do
+#       write("this is a test")
+#     end
+#
+def callwith(*objs, &block)
+  last = nil
+  objs.each do |obj|
+    p = CallWith.create(obj, self)
+    last = p.__instance_eval__(&block)
+  end
+  return last
+end
+
+class CallWith
+  def method_missing(method, *args, &block)
+    obj = __with__obj__()
+    self_obj = __with__self_obj__()
+
+    if obj.respond_to?(method)
+      obj.__send__(method, *args, &block)
+    else
+      self_obj.__send__(method, *args, &block)
+    end
+  end
+end
+

data/test/test_callwith.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require 'with'
+
+class WithTest < Test::Unit::TestCase
+  class SelfObj
+    def initialize
+      @ivar = "self_obj_ivar"
+    end
+
+    def self_obj_method
+      return "self_obj_method"
+    end
+  end
+
+  class DelegateObj
+    def initialize
+      @ivar = "delegate_obj_ivar"
+    end
+
+    def delegate_obj_method
+      return "delegate_obj_method"
+    end
+  end
+
+  class DelegateObj2
+    def initialize
+      @ivar = "delegate_obj_2_ivar"
+    end
+
+    def delegate_obj_method
+      return "delegate_obj_2_method"
+    end
+  end
+
+  def test_with_can_call_self_obj
+    self_obj = SelfObj.new
+    delegate_obj = DelegateObj.new
+    result = self_obj.instance_eval do
+      with(delegate_obj) do
+        self_obj_method()
+      end
+    end
+    assert_equal "self_obj_method", result
+  end
+
+  def test_with_can_call_delegate_obj
+    self_obj = SelfObj.new
+    delegate_obj = DelegateObj.new
+    result = self_obj.instance_eval do
+      with(delegate_obj) do
+        delegate_obj_method()
+      end
+    end
+    assert_equal "delegate_obj_method", result
+  end
+
+  def test_with_can_access_self_ivars
+    self_obj = SelfObj.new
+    delegate_obj = DelegateObj.new
+    result = self_obj.instance_eval do
+      with(delegate_obj) do
+        @ivar
+      end
+    end
+    assert_equal "self_obj_ivar", result
+  end
+
+  def test_with_can_iterate_over_delegates
+    self_obj = SelfObj.new
+    delegate_obj_1 = DelegateObj.new
+    delegate_obj_2 = DelegateObj2.new
+    results = [ ]
+    self_obj.instance_eval do
+      with(delegate_obj_1, delegate_obj_2) do
+        results << delegate_obj_method()
+      end
+    end
+    assert_equal [ "delegate_obj_method", "delegate_obj_2_method" ], results
+  end
+end
+

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: callwith
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul Brannan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-19 00:00:00 Z
+dependencies: []
+
+description: |
+  Object#callwith is like instance_eval, but can still delegate back to
+  the original object if a method is not found.  Also unlike
+  instance_eval, all instance variables accessed within the block
+  reference the original self object.
+
+email: curlypaul924@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.md
+files: 
+- ext/extconf.rb
+- ext/callwith_ext.c
+- lib/callwith.rb
+- test/test_callwith.rb
+- README.md
+homepage: http://github.com/cout/with/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Call with objects
+test_files: 
+- test/test_callwith.rb