gen_eval 0.3.0

data/LICENSE

@@ -0,0 +1,20 @@
+/* Copyright (c) 2007 Scott Lembcke
+ * 
+ * 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.rdoc

@@ -0,0 +1,24 @@
+gen_eval is a homebrew version of instance_eval that eliminates the most annoying aspect of instance_eval.
+
+For example:
+
+    @x = 20
+    @y = 30
+    my_image.instance_eval {
+        circle @x, @y, 20 
+    }
+
+    => error @x not initialized
+
+In the above code you meant to access the local @x yet instance_eval looks up @x in the receiver (my_image).
+
+gen_eval, on the other hand, works as you'd expect, it looks up @x in the caller-context yet still invokes methods in the receiver-context.
+
+This means we can now do things like this:
+
+    @x = 20
+    @y = 30
+    image.gen_eval {
+        pixel @x, @y
+        circle @x, @y, 20 
+    }

data/Rakefile

@@ -0,0 +1,77 @@
+require 'rake/clean'
+#require 'rake/extensiontask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'lib/gen_eval/version'
+
+dlext = Config::CONFIG['DLEXT']
+direc = File.dirname(__FILE__)
+
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/.log", "ext/**/.o", "ext/**/*~", "ext/**/*#*", "ext/**/.obj", "ext/**/.def", "ext/**/.pdb")
+CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o", "doc/**")
+
+spec = Gem::Specification.new do |s|
+    s.name = "gen_eval"
+    s.summary = "a strange new breed of instance_eval"
+    s.description = s.summary
+    s.version = GenEval::VERSION
+    s.author = "John Mair (banisterfiend)"
+    s.email = 'jrmair@gmail.com'
+    s.date = Time.now.strftime '%Y-%m-%d'
+    s.require_path = 'lib'
+    s.homepage = "http://banisterfiend.wordpress.com"
+    s.platform = Gem::Platform::RUBY #'i386-mswin32'
+    s.extensions = FileList["ext/**/extconf.rb"]
+    s.has_rdoc = true
+    s.add_dependency("object2module",">=0.3.0")
+    s.files = ["Rakefile", "README.rdoc", "LICENSE", "lib/gen_eval.rb"] + FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c", "lib/gen_eval/version.rb"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+end
+
+ext_direc = "#{direc}/ext/gen_eval"
+
+file "#{ext_direc}/Makefile" => "#{ext_direc}/extconf.rb" do
+  chdir(ext_direc) do
+    sh 'ruby extconf.rb'
+  end
+end
+
+directory "#{direc}/lib/1.9"
+directory "#{direc}/lib/1.8"
+
+file "#{ext_direc}/gen_eval.#{dlext}" => ["#{ext_direc}/Makefile", "#{direc}/lib/1.9", "#{direc}/lib/1.8"] do
+  chdir(ext_direc) do
+    sh 'make'
+
+    if RUBY_VERSION =~ /1.9/
+      cp "gen_eval.#{dlext}", "#[direc}/lib/1.9/"
+      puts "built gen_eval.#{dlext} and copied to #{direc}/lib/1.9"
+    elsif RUBY_VERSION =~ /1.8/
+      cp "gen_eval.#{dlext}", "#[direc}/lib/1.8/"
+      puts "built gen_eval.#{dlext} and copied to #{direc}/lib/1.8"
+    else
+      raise "Error, Rakefile only supports Ruby 1.8 and 1.9"
+    end
+  end
+end
+
+task :compile => "#{ext_direc}/gen_eval.#{dlext}"
+
+    
+  
+
+# Rake::ExtensionTask.new('mult', spec)  do |ext|
+#     ext.config_script = 'extconf.rb' 
+#     ext.cross_compile = true                
+#     ext.cross_platform = 'i386-mswin32'
+# end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/gen_eval.rb")
+end
+

data/ext/gen_eval/compat.h

@@ -0,0 +1,18 @@
+/* contains basic macros to facilitate ruby 1.8 and ruby 1.9 compatibility */
+
+#ifndef GUARD_COMPAT_H
+#define GUARD_COMPAT_H
+
+#include <ruby.h>
+
+/* macros for backwards compatibility with 1.8 */
+#ifndef RUBY_19
+# define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+# define RCLASS_SUPER(c) (RCLASS(c)->super)
+# define RCLASS_IV_TBL(c) (RCLASS(c)->iv_tbl)
+#endif
+
+/* a useful macro. cannot use ordinary CLASS_OF as it does not return an lvalue */
+#define KLASS_OF(c) (RBASIC(c)->klass)
+
+#endif

data/ext/gen_eval/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+# 1.9 compatibility
+$CFLAGS += " -DRUBY_19" if RUBY_VERSION =~ /1.9/
+
+# let's use c99
+$CFLAGS += " -std=c99"
+
+create_makefile('gen_eval')

data/ext/gen_eval/gen_eval.c

@@ -0,0 +1,192 @@
+/* gen_eval.c */
+/* (C) John Mair 2009
+ * This program is distributed under the terms of the MIT License
+ *                                                                */
+
+#include <ruby.h>
+#include "compat.h"
+
+VALUE
+retrieve_hidden_self(VALUE duped_context)
+{
+    VALUE thread_id, unique_name, hidden_self;
+    
+    /* retrieve hidden self (if it exists) */
+    thread_id = rb_funcall(rb_obj_id(rb_thread_current()), rb_intern("to_s"), 0);
+    unique_name = rb_str_plus(rb_str_new2("__hidden_self__"), thread_id);
+    hidden_self = rb_ivar_get(duped_context, rb_to_id(unique_name));
+
+    return hidden_self;
+}
+
+VALUE
+remove_hidden_self(VALUE duped_context)
+{
+    /* retrieve hidden self (if it exists) */
+    VALUE thread_id, unique_name;
+    
+    thread_id = rb_funcall(rb_obj_id(rb_thread_current()), rb_intern("to_s"), 0);
+    unique_name = rb_str_plus(rb_str_new2("__hidden_self__"), thread_id);
+    
+    rb_obj_remove_instance_variable(duped_context, unique_name);
+
+    return Qnil;
+}
+
+VALUE
+set_hidden_self(VALUE duped_context, VALUE hidden_self)
+{
+    VALUE thread_id, unique_name;
+    
+    /* generate a unique (thread safe) name for the hidden self  */
+    thread_id = rb_funcall(rb_obj_id(rb_thread_current()), rb_intern("to_s"), 0);
+    unique_name = rb_str_plus(rb_str_new2("__hidden_self__"), thread_id);
+
+    /* store self in hidden var in duped context */
+    rb_ivar_set(duped_context, rb_to_id(unique_name), hidden_self);
+
+    return Qnil;
+}
+
+static void
+save_m_tbl(VALUE klass)
+{
+    rb_iv_set(klass, "__saved_m_tbl__", (VALUE)RCLASS_M_TBL(klass));
+}
+
+static void
+restore_m_tbl(VALUE klass)
+{
+    RCLASS_M_TBL(klass) = (struct st_table *)rb_iv_get(klass, "__saved_m_tbl__");
+}
+
+/* we do not want any ROBJECT_EMBED objects, so ensure we have > 3 ivars */
+static void
+force_iv_tbl(VALUE obj)
+{
+  rb_iv_set(obj, "__force_iv_tbl_1__", Qtrue);
+  rb_iv_set(obj, "__force_iv_tbl_2__", Qtrue);
+  rb_iv_set(obj, "__force_iv_tbl_3__", Qtrue);
+  rb_iv_set(obj, "__force_iv_tbl_4__", Qtrue);
+}
+
+#ifdef RUBY_19
+static void
+redirect_iv_for_object(VALUE obj, VALUE dest)
+{
+    if(TYPE(obj) != T_OBJECT)
+        rb_raise(rb_eArgError, "must provide a T_OBJECT");
+
+    /* ensure ivars are stored on the heap and not embedded */
+    force_iv_tbl(obj);
+
+    if (!(RBASIC(dest)->flags & ROBJECT_EMBED) && ROBJECT_IVPTR(dest)) {
+        rb_raise(rb_eArgError, "im sorry gen_eval does not yet work with this type of ROBJECT");
+    }
+    if (RBASIC(obj)->flags & ROBJECT_EMBED) {
+        rb_raise(rb_eArgError, "im sorry gen_eval does not yet work with R_OBJECT_EMBED types");
+    }
+    else {
+        ROBJECT(dest)->as.heap.ivptr = ROBJECT(obj)->as.heap.ivptr;
+        ROBJECT(dest)->as.heap.numiv = ROBJECT(obj)->as.heap.numiv;
+        ROBJECT(dest)->as.heap.iv_index_tbl = ROBJECT(obj)->as.heap.iv_index_tbl;
+        RBASIC(dest)->flags &= ~ROBJECT_EMBED;
+    }
+}
+
+static void
+release_iv_for_object(VALUE obj)
+{
+    if(TYPE(obj) != T_OBJECT)
+        rb_raise(rb_eArgError, "must provide a T_OBJECT");
+    
+    ROBJECT(obj)->as.heap.ivptr = (void *) 0;
+    ROBJECT(obj)->as.heap.numiv = 0;
+    ROBJECT(obj)->as.heap.iv_index_tbl = (void *) 0;
+    RBASIC(obj)->flags &= ~ROBJECT_EMBED;
+}
+#endif
+/** end of Ruby 1.9 funcs **/
+
+VALUE
+rb_mirror_object(VALUE context)
+{
+    VALUE duped_context;
+  
+#ifdef RUBY_19
+    if(TYPE(context) == T_OBJECT)
+        duped_context = rb_funcall(rb_cObject, rb_intern("new"), 0);
+    else 
+        duped_context = rb_funcall(rb_cClass, rb_intern("new"), 0);
+
+#else
+    duped_context = rb_funcall(rb_cClass, rb_intern("new"), 0);
+#endif    
+    
+    /* the duped_context shares the context's iv_tbl.
+       2 cases: (1) external iv_tbl, (2) local iv_tbl
+       
+       NOTE: we do not need to save original iv_tbl before replacing it, a brand new Class
+       instance does not yet have an iv_tbl (the pointer is set to 0) 
+    */
+    if(FL_TEST(context, FL_EXIVAR)) 
+        RCLASS_IV_TBL(duped_context) = (struct st_table *) rb_generic_ivar_table(context);
+    else {
+#ifdef RUBY_19
+        if(TYPE(context) == T_OBJECT)
+            redirect_iv_for_object(context, duped_context);
+        else {
+            save_m_tbl(duped_context);
+            RCLASS_M_TBL(duped_context) = (struct st_table *) RCLASS_M_TBL(context);
+            RCLASS_IV_TBL(duped_context) = (struct st_table *) RCLASS_IV_TBL(context);
+        }
+#else
+        save_m_tbl(duped_context);
+        RCLASS_M_TBL(duped_context) = (struct st_table *) RCLASS_M_TBL(context);
+        RCLASS_IV_TBL(duped_context) = (struct st_table *) RCLASS_IV_TBL(context);
+#endif        
+
+        
+    }
+
+    /* ensure singleton exists */
+    rb_singleton_class(context);
+    
+    /* set up the class hierarchy for our dup_context */
+    KLASS_OF(duped_context) = rb_singleton_class_clone(context);
+
+    return duped_context;
+}
+
+VALUE
+rb_unmirror_object(VALUE duped_context)
+{
+#ifdef RUBY_19
+    if(TYPE(duped_context) == T_OBJECT)
+        release_iv_for_object(duped_context);
+    else {
+        RCLASS_IV_TBL(duped_context) = (struct st_table *) 0;
+        restore_m_tbl(duped_context);
+    }
+#else
+    RCLASS_IV_TBL(duped_context) = (struct st_table *) 0;
+    restore_m_tbl(duped_context);
+#endif
+
+    return Qnil;
+}
+  
+void
+Init_gen_eval()
+{
+    rb_define_method(rb_cObject, "__mirror__", rb_mirror_object, 0);
+    rb_define_method(rb_cObject, "__unmirror__", rb_unmirror_object, 0);
+    rb_define_method(rb_cObject, "__set_hidden_self__", set_hidden_self, 1);
+    rb_define_method(rb_cObject, "__retrieve_hidden_self__", retrieve_hidden_self, 0);
+    rb_define_method(rb_cObject, "__remove_hidden_self__", retrieve_hidden_self, 0);
+}
+
+    
+    
+
+    

data/ext/gen_eval/gen_eval.h

@@ -0,0 +1,23 @@
+/* gen_eval.h */
+
+#ifndef GUARD_GEN_EVAL_H
+#define GUARD_GEN_EVAL_H
+
+#include <ruby.h>
+
+VALUE retrieve_hidden_self(VALUE duped_context);
+void set_hidden_self(VALUE duped_context, VALUE hidden_self);
+VALUE remove_hidden_self(VALUE duped_context);
+VALUE rb_mirror_object(VALUE context);
+VALUE rb_unmirror_object(VALUE duped_context);
+
+
+
+/* change self to hidden self if __hidden_self__ defined */
+#define ADJUST_SELF(X)                                                    \
+  do {                                                                    \
+      if(!NIL_P(retrieve_hidden_self((X))))                               \
+          (X) = retrieve_hidden_self((X));                                \
+  } while(0)
+        
+#endif

data/lib/gen_eval/version.rb

@@ -0,0 +1,3 @@
+module GenEval
+  VERSION = "0.3.0"
+end  

data/lib/gen_eval.rb

@@ -0,0 +1,103 @@
+# (C) John Mair 2009, under the MIT licence
+
+require 'rbconfig'
+require 'object2module'
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/1.9/gen_eval.#{dlext}"
+    else
+        require "#{direc}/1.8/gen_eval.#{dlext}"
+    end
+rescue LoadError => e
+    require "#{direc}/gen_eval.#{dlext}"
+end
+require "#{direc}/gen_eval/version"
+
+class Proc  #:nodoc:
+    def __context__ 
+        eval('self', self.binding)
+    end
+end
+
+
+class Object
+    
+  #  call-seq:
+  #     obj.gen_eval {| | block }                       => obj
+  #  
+  #  Works similarly to instance_eval except instance variables are
+  #  not looked up in _obj_. All instance methods of +Klass+ are
+  #  available but mutators must be wrapped in a +capture+ block.
+  #     
+  #     class Klass
+  #       attr_reader :age
+  #  
+  #       def hello(name)
+  #         "hello #{name}"
+  #       end
+  #
+  #       def set_age(age)
+  #         capture { 
+  #           @age = age
+  #         }
+  #       end
+  #     end
+  #     k = Klass.new
+  #     @name = "John"
+  #     k.gen_eval { hello(@name) }   #=> "hello John"
+  #
+  #     k.gen_eval { set_age(21) }
+  #     k.age #=> 21
+  def gen_eval(*objs, &block)
+      raise "block needed" if !block
+
+      objs = [self] if objs.empty?
+
+      raise "cannot gen_eval on Object" if objs.include?(Object)
+
+      mirror_context = block.__context__.__mirror__
+      mirror_context.gen_extend(*objs)
+      mirror_context.__set_hidden_self__(self)
+
+      begin
+          m = mirror_context.is_a?(Module) ? :module_eval : :instance_eval
+          result = mirror_context.send(m, &block)
+      ensure
+          mirror_context.__remove_hidden_self__
+          mirror_context.__unmirror__
+      end
+
+      result
+    end
+
+    alias_method :gen_eval_with, :gen_eval
+      
+    #  call-seq:
+    #     capture {| | block }                       => result
+    #  
+    #  Used in conjunction with +gen_eval+. Causes code in block
+    #  to be +instance_eval+'d with respect to the receiver of
+    #  the +gen_eval+.
+    def capture(&block)
+        raise "block needed" if !block
+
+        hidden_self = self.__retrieve_hidden_self__
+
+        if hidden_self
+            result = hidden_self.instance_eval(&block)
+        else
+            result = yield
+        end
+
+        result
+    end
+    
+end
+
+
+
+  

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: gen_eval
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- John Mair (banisterfiend)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-31 00:00:00 +12:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: object2module
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id001
+description: a strange new breed of instance_eval
+email: jrmair@gmail.com
+executables: []
+
+extensions: 
+- ext/gen_eval/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.rdoc
+- LICENSE
+- lib/gen_eval.rb
+- ext/gen_eval/extconf.rb
+- ext/gen_eval/compat.h
+- ext/gen_eval/gen_eval.h
+- ext/gen_eval/gen_eval.c
+- lib/gen_eval/version.rb
+has_rdoc: true
+homepage: http://banisterfiend.wordpress.com
+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.3.7
+signing_key: 
+specification_version: 3
+summary: a strange new breed of instance_eval
+test_files: []
+