local_eval 0.2.0 → 0.2.2

data/README.markdown

@@ -38,32 +38,48 @@ block:
 example: capture
 --------------------
 
-`gen_extend` lets us mix objects into objects:
-
-    o = Object.new
-    class << o
-      def bye
-        :bye
+Since `local_eval` does not alter the `self` inside a block,
+all methods with an implied receiver will be invoked with respect to
+this self. This means that all mutator methods defined on the receiver
+will modify state on the block's self rather than on the receiver's
+self. This is unlikely to be the desired behaviour; and so
+using the `capture` method we can redirect the method lookup to
+the actual receiver. All code captured by the `capture` block
+will be `instance_eval`'d against the actual receiver of the method.
+     
+    class C
+      class << self
+        attr_reader :hello
+        def self.capture_test
+         
+          # this code will be run against C
+          capture { @hello = :captured }
+    
+          # this code will be run against the block context
+          @goodbye = :goobye
+        end
       end
     end
-
-    n = Object.new
-    n.gen_extend o
-    n.bye #=> :bye
     
+    C.local_eval { capture_test }
+
+    C.hello #=> :captured
+    @goodbye #=> :goodbye
+
 How it works
 --------------
 
-Object2module simply removes the check for `T_MODULE` from `rb_include_module()`
+Makes use of companion libraries: Remix and Object2module
 
 Companion Libraries
 --------------------
 
-Remix is one of a series of experimental libraries that mess with
+LocalEval is one of a series of experimental libraries that mess with
 the internals of Ruby to bring new and interesting functionality to
 the language, see also:
 
 * [Remix](http://github.com/banister/remix) - Makes ancestor chains read/write
+* [Object2module](http://github.com/banister/object2module) - Enables you to include/extend Object/Classes.
 * [Include Complete](http://github.com/banister/include_complete) - Brings in
   module singleton classes during an include. No more ugly ClassMethods and included() hook hacks.
 * [Prepend](http://github.com/banister/prepend) - Prepends modules in front of a class; so method lookup starts with the module

data/Rakefile

@@ -18,8 +18,8 @@ def apply_spec_defaults(s)
   s.email = 'jrmair@gmail.com'
   s.description = s.summary
   s.require_path = 'lib'
-  s.add_dependency("remix",">=0.4.8")
-  s.add_dependency("object2module",">=0.4.3")
+  s.add_dependency("remix",">=0.4.9")
+  s.add_dependency("object2module",">=0.4.5")
   s.homepage = "http://banisterfiend.wordpress.com"
   s.has_rdoc = 'yard'
   s.files = Dir["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c", "lib/**/*.rb",

data/lib/local_eval/version.rb

@@ -1,3 +1,3 @@
 module LocalEval
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/local_eval.rb

@@ -5,25 +5,25 @@ require 'remix'
 require 'object2module'
 
 module LocalEval
-
-  # Thread-local name for the hidden self used by `capture`
-  # @return [String] The name of the hidden self used by `capture`
-  def self.context_self_name
-    "@__self__#{Thread.current.object_id}"
-  end
-
-  module ClassExtensions
-    
-    # Find the instance associated with the singleton class
-    # @return [Object] Instance associated with the singleton class
-    def __attached__
-      ObjectSpace.each_object(self).first
-    end
-  end
   
   module ObjectExtensions
 
-    def local_eval(*objs, &block)
+    # A more general version of `local_eval`.
+    # `local_eval_with` allows you to inject arbitrary functionality
+    # from any number of objects into the block. 
+    # @param [Array] objs The objects to provide functionality to the block
+    # @return The value of the block
+    # @example
+    #   class A; def self.a; puts "a"; end; end
+    #   class B; def self.b; puts "b"; end; end
+    #   class C; def self.c; puts "c"; end; end
+    #   local_eval_with(A, B, C) { a; b; c }
+    #   #=> "a"
+    #   #=> "b"
+    #   #=> "c"
+    def local_eval_with(*objs, &block)
+      raise "need a block" if !block_given?
+      
       objs = Array(self) if objs.empty?
       context = eval('self', block.binding)
 
@@ -40,11 +40,58 @@ module LocalEval
       # mix the anonymous module into the block context
       context.temp_extend functionality, &block
     end
-    alias_method :local_eval_with, :local_eval
-
-    # This form is meant to be called without a receiver
     private :local_eval_with
 
+    # Performs a `local_eval` on the block with respect to the
+    # receiver.
+    # `local_eval` has some advantages over `instance_eval` in that it
+    # does not change `self`. Instead, the functionality in the block
+    # context is supplemented by the functionality in the
+    # receiver. 
+    # @return The return value of the block
+    # @yield The block to `local_eval`
+    # @example local ivars can be looked up
+    #   class C
+    #     def hello(name)
+    #       "hello #{name}!"
+    #     end
+    #   end
+    #   
+    #   o = C.new
+    #   
+    #   @name = "John"
+    #   o.local_eval { hello(@name) } #=> "hello John!"
+    def local_eval(&block)
+      local_eval_with(&block)
+    end
+
+    # Since `local_eval` does not alter the `self` inside a block,
+    # all methods with an implied receiver will be invoked with respect to
+    # this self. This means that all mutator methods defined on the receiver
+    # will modify state on the block's self rather than on the receiver's
+    # self. This is unlikely to be the desired behaviour; and so
+    # using the `capture` method we can redirect the method lookup to
+    # the actual receiver. All code captured by the `capture` block
+    # will be `instance_eval`'d against the actual receiver of the
+    # method.
+    # @return The return value of the block.
+    # @yield The block to be evaluated in the receiver's context.
+    # @example
+    #   class C
+    #     def self.hello() @hello end
+    #     def self.capture_test
+    #     
+    #       # this code will be run against C
+    #       capture { @hello = :captured }
+    #
+    #       # this code will be run against the block context
+    #       @goodbye = :goobye
+    #     end
+    #   end
+    #
+    #   C.local_eval { capture_test }
+    #   C.hello #=> :captured
+    #   @goodbye #=> :goodbye
     def capture(&block)
       
       # 1. Get name of enclosing method (method that invoked
@@ -59,13 +106,11 @@ module LocalEval
       attached_object = method_owner.__attached__
       attached_object.instance_eval &block
     end
+    alias_method :__capture__, :capture
+    
   end
 end
 
-class Class
-  include LocalEval::ClassExtensions
-end
-
 class Object
   include LocalEval::ObjectExtensions
 end

data/lib/local_eval_flymake.rb

@@ -0,0 +1,133 @@
+direc = File.dirname(__FILE__)
+
+require "#{direc}/local_eval/version"
+require 'remix'
+require 'object2module'
+
+module LocalEval
+  module ClassExtensions
+    
+    # Find the instance associated with the singleton class
+    # @return [Object] Instance associated with the singleton class
+    def __attached__
+      ObjectSpace.each_object(self).first
+    end
+  end
+  
+  module ObjectExtensions
+
+    # A more general version of `local_eval`.
+    # `local_eval_with` allows you to inject arbitrary functionality
+    # from any number of objects into the block. Methods that use a
+    # `capture` block are invoked on the object that defines the
+    # method (and not the local context).
+    # @param [Array] objs The objects to provide functionality to the block
+    # @return The value of the block
+    # @example
+    #   class A; def self.a; puts "a"; end; end
+    #   class B; def self.b; puts "b"; end; end
+    #   class C; def self.c; puts "c"; end; end
+    #   local_eval_with(A, B, C) { a; b; c }
+    #   #=> "a"
+    #   #=> "b"
+    #   #=> "c"
+    def local_eval_with(*objs, &block)
+      raise "need a block" if !block_given?
+      
+      objs = Array(self) if objs.empty?
+      context = eval('self', block.binding)
+
+      # if the receiver is the same as the block context then don't
+      # mix in anything, as functionality is already present.
+      if objs.include?(context)
+        objs.delete(context)
+        return yield if objs.empty?
+      end
+
+      # add functionality to anonymous module to ease mixing and unmixing
+      functionality = Module.new.gen_include *objs.map { |o| o.is_a?(Module) ? o.singleton_class : o }
+      
+      # mix the anonymous module into the block context
+      context.temp_extend functionality, &block
+    end
+    private :local_eval_with
+
+    # Performs a `local_eval` on the block with respect to the
+    # receiver.
+    # `local_eval` has some advantages over `instance_eval` in that it
+    # does not change `self`. Instead, the functionality in the local
+    # context is supplemented by the functionality in the
+    # receiver. Further, if receiver methods utilize a `capture` block
+    # then the receiver of that `local_eval` becomes the receiver of that
+    # method call (rather than the local context).
+    # @return The return value of the block
+    # @yield The block to `local_eval`
+    # @example local ivars can be looked up
+    #   class C
+    #     def hello(name)
+    #       "hello #{name}!"
+    #     end
+    #   end
+    #   
+    #   o = C.new
+    #   
+    #   @name = "John"
+    #   o.local_eval { hello(@name) } #=> "hello John!"
+    def local_eval(&block)
+      local_eval_with(&block)
+    end
+
+    # Since `local_eval` does not alter the `self` inside a block,
+    # all methods with an implied receiver will be invoked with respect to
+    # this self. This means that all mutator methods defined on the receiver
+    # will modify state on the block's self rather than on the receiver's
+    # self. This is unlikely to be the desired behaviour; and so
+    # using the `capture` method we can redirect the method lookup to
+    # the actual receiver. All code captured by the `capture` block
+    # will be `instance_eval`'d against the actual receiver of the
+    # method.
+    # @return The return value of the block.
+    # @yield The block to be evaluated in the receiver's context.
+    # @example
+    #   class C
+    #     attr_reader :hello
+    #     def self.capture_test
+    #     
+    #       # this code will be run against C
+    #       capture { @hello = :captured }
+    #
+    #       # this code will be run against the block context
+    #       @goodbye = :goobye
+    #     end
+    #   end
+    #
+    #   C.local_eval { capture_test }
+    #   C.hello #=> :captured
+    #   @goodbye #=> :goodbye
+    def capture(&block)
+      
+      # 1. Get name of enclosing method (method that invoked
+      # `capture ` block)
+      # 2. Find owner of enclosing method (owner is guaranteed to be
+      # a singleton class)
+      # 4. Find associated object (attached object) of the singleton class
+      # 5. This object will be the receiver of the method call, so
+      # instance_eval on it.
+      method_name = eval('__method__', block.binding)
+
+      method_owner = method(method_name).owner
+      attached_object = method_owner.__attached__
+      attached_object.instance_eval &block
+    end
+    alias_method :__capture__, :capture
+    
+  end
+end
+
+class Class
+  include LocalEval::ClassExtensions
+end
+
+class Object
+  include LocalEval::ObjectExtensions
+end

data/test/helper1.rb

@@ -5,7 +5,7 @@ end
 Reset = proc do 
   O = Object.new
   O2 = Object.new
-
+  O3 = Object.new
   class A
     def self.a
       :a
@@ -23,7 +23,7 @@ Reset = proc do
       :o
     end
 
-    def ivar_set(var, val)
+    def ivar_set1(var, val)
       instance_variable_set(var, val)
     end
 
@@ -43,6 +43,16 @@ Reset = proc do
     end
   end
 
+  class << O3
+    def receiver_ivar_set3
+      capture {
+        @receiver_ivar3 = :receiver3
+      }
+      @ivar3 = :ivar3
+    end
+  end
+
+
   class C
     def self.build_proc
       proc { love }

data/test/helper1_flymake.rb

@@ -0,0 +1,83 @@
+class Module
+  public :remove_const, :include, :remove_method
+end
+
+Reset = proc do 
+  O = Object.new
+  O2 = Object.new
+  O3 = Object.new
+  class A
+    def self.a
+      :a
+    end
+  end
+
+  class B
+    def self.b
+      :b
+    end
+  end
+
+  class << O
+    def hello
+      :o
+    end
+
+    def ivar_set1(var, val)
+      instance_variable_set(var, val)
+    end
+
+    def receiver_ivar_set
+      capture {
+        @receiver_ivar = :receiver
+      }
+    end
+    
+  end
+
+  class << O2
+    def receiver_ivar_set2
+      capture {
+        @receiver_ivar2 = :receiver2
+      }
+    end
+  end
+
+  class << O3
+    def receiver_ivar_set3
+      capture {
+        @receiver_ivar3 = :receiver3
+      }
+      @ivar3 = :ivar3
+    end
+  end
+
+
+  class C
+    def self.build_proc
+      proc { love }
+    end
+    
+    def self.hello
+      :c
+    end
+
+    def self.c
+      :c
+    end
+
+    def self.ivar(v)
+      v
+    end
+  end
+
+  module M
+    def self.hello
+      :m
+    end
+
+    def m
+      :m
+    end
+  end
+end

data/test/test.rb

@@ -14,7 +14,7 @@ describe LocalEval do
   end
 
   after do
-    [:A, :B, :C, :M, :O, :O2].each do |c|
+    [:A, :B, :C, :M, :O, :O2, :O3].each do |c|
       Object.remove_const(c)
     end
   end
@@ -77,9 +77,9 @@ describe LocalEval do
 
     it 'should make the method set a local ivar' do
       instance_variable_defined?(:@v).should == false
-      lambda { ivar_set }.should.raise NameError
-      O.local_eval { ivar_set(:@v, 10) }
-      lambda { ivar_set }.should.raise NameError
+      lambda { ivar_set1 }.should.raise NameError
+      O.local_eval { ivar_set1(:@v, 10) }
+      lambda { ivar_set1 }.should.raise NameError
       @v.should == 10
     end
       
@@ -130,6 +130,24 @@ describe LocalEval do
       O2.instance_variable_get(:@receiver_ivar2).should == :receiver2
       O.instance_variable_get(:@receiver_ivar).should == :receiver
     end
+
+    it 'should separate the two different selves in a method when using capture' do
+      O3.instance_variable_defined?(:@receiver_ivar).should == false
+      instance_variable_defined?(:@ivar3).should == false
+      O3.local_eval { receiver_ivar_set3 }
+      O3.instance_variable_get(:@receiver_ivar3).should == :receiver3
+      instance_variable_get(:@ivar3).should == :ivar3
+      remove_instance_variable(:@ivar3)
+    end
+
+    it 'should work in an instance_eval' do
+      o = Object.new
+      o.instance_eval do
+        O3.local_eval { receiver_ivar_set3 }
+        O3.instance_variable_get(:@receiver_ivar3).should == :receiver3
+        instance_variable_get(:@ivar3).should == :ivar3
+      end
+    end
   end
   
   describe 'mixing in a module' do

data/test/test_flymake.rb

@@ -0,0 +1,152 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/local_eval"
+require "#{direc}/helper1"
+
+puts "Testing LocalEval version #{LocalEval::VERSION}..."
+puts "With Remix version #{Remix::VERSION} and Object2module version #{Object2module::VERSION}"
+puts "Ruby version #{RUBY_VERSION}"
+
+describe LocalEval do
+  before do
+    Reset.call
+  end
+
+  after do
+    [:A, :B, :C, :M, :O, :O2, :O3].each do |c|
+      Object.remove_const(c)
+    end
+  end
+  
+  describe 'mixing in an object' do
+    it 'should mix in and mixout the object and make functionality available to block' do
+      lambda { hello }.should.raise NameError
+      O.local_eval { hello }.should == :o
+      lambda { hello }.should.raise NameError
+    end
+
+    it 'should not error when receiver is the same as block context' do
+      lambda { local_eval { :hello } }.should.not.raise ArgumentError
+      local_eval { :hello }.should == :hello
+    end
+
+    it 'should mix implicit self into context of block' do
+      def self.love; :love; end
+      local_eval(&C.build_proc).should == :love
+      self.singleton_class.remove_method(:love)
+    end
+  end
+
+  describe 'local_eval_with' do
+    it 'should mix in multiple objects and make functionality available to the block' do
+      lambda { a }.should.raise NameError
+      lambda { b }.should.raise NameError
+      lambda { local_eval_with(A, B) { a; b; } }.should.not.raise NameError
+      lambda { a }.should.raise NameError
+      lambda { b }.should.raise NameError
+    end
+
+    it 'should not error when mixing in multiple objects that include the context of the block' do
+      lambda { local_eval_with(self, A, B) { a; b } }.should.not.raise NameError
+    end
+  end
+  
+  describe 'mixing in a class' do
+    it 'should mix in and mixout the class' do
+      lambda { hello }.should.raise NameError
+      C.local_eval { c }.should == :c
+      lambda { hello }.should.raise NameError
+    end
+
+    it 'should mixin and mixout a class/module chain' do
+      C.extend M
+      lambda { c }.should.raise NameError
+      lambda { m }.should.raise NameError
+      C.local_eval { c.should == :c; m.should == :m }
+      lambda { c }.should.raise NameError
+      lambda { m }.should.raise NameError
+    end
+  end
+
+  describe 'ivars in the block' do
+    it 'should make ivars accessible to, and modifiable by, block' do
+      O.local_eval { @x = 5 }
+      @x.should == 5
+    end
+
+    it 'should make the method set a local ivar' do
+      instance_variable_defined?(:@v).should == false
+      lambda { ivar_set }.should.raise NameError
+      O.local_eval { ivar_set(:@v, 10) }
+      lambda { ivar_set }.should.raise NameError
+      @v.should == 10
+    end
+      
+    it 'should make local ivars accessible to mixed in methods' do
+      @y = 10
+      lambda { ivar(@y) }.should.raise NameError
+      C.local_eval { ivar(@y) }.should == 10
+      @y.should == 10
+      lambda { ivar(@y) }.should.raise NameError
+    end
+  end
+
+  describe 'capture block' do
+    it 'should make capture evaluate the method in receiver context' do
+      instance_variable_defined?(:@receiver_ivar).should == false
+      lambda { receiver_ivar_set }.should.raise NameError
+      O.local_eval { receiver_ivar_set }
+      instance_variable_defined?(:@receiver_ivar).should == false
+      O.instance_variable_get(:@receiver_ivar).should == :receiver
+    end
+
+    it 'should redirect methods to appropriate receivers' do
+      O.instance_variable_defined?(:@receiver_ivar2).should == false
+      O2.instance_variable_defined?(:@receiver_ivar2).should == false
+      instance_variable_defined?(:@receiver_ivar).should == false
+      instance_variable_defined?(:@receiver_ivar2).should == false
+      lambda { receiver_ivar_set; receiver_ivar_set2 }.should.raise NameError
+      local_eval_with(O, O2) { receiver_ivar_set; receiver_ivar_set2 }
+      instance_variable_defined?(:@receiver_ivar).should == false
+      instance_variable_defined?(:@receiver_ivar2).should == false
+      O.instance_variable_get(:@receiver_ivar).should == :receiver
+      O2.instance_variable_get(:@receiver_ivar2).should == :receiver2
+    end
+
+    it 'should not prevent method lookup on capture-methods on objects that are not involved in the local_eval' do
+      O2.instance_variable_defined?(:@receiver_ivar2).should == false
+      O.local_eval { O2.receiver_ivar_set2.should == :receiver2 }
+      O2.instance_variable_get(:@receiver_ivar2).should == :receiver2
+    end
+
+    it 'should work properly with nested local_evals' do
+      O.local_eval do
+        O2.local_eval { receiver_ivar_set2 }
+        lambda { receiver_ivar_set2 }.should.raise NameError
+        receiver_ivar_set
+      end
+
+      O2.instance_variable_get(:@receiver_ivar2).should == :receiver2
+      O.instance_variable_get(:@receiver_ivar).should == :receiver
+    end
+
+    it 'should separate the two different selves in a method when using capture' do
+      O3.instance_variable_defined?(:@receiver_ivar).should == false
+      instance_variable_defined?(:@ivar3).should == false
+      O3.local_eval { receiver_ivar_set3 }
+      O3.instance_variable_get(:@receiver_ivar3).should == :receiver3
+      instance_variable_get(:@ivar3).should == :ivar3
+      remove_instance_variable(:@ivar3)
+    end
+
+  end
+  
+  describe 'mixing in a module' do
+    it 'should mix in and mixout the module' do
+      lambda { hello }.should.raise NameError
+      M.local_eval { hello }.should == :m
+      lambda { hello }.should.raise NameError
+    end
+  end  
+end

data/test/test_segfault.rb

@@ -0,0 +1,26 @@
+direc = File.dirname(__FILE__)
+require "rubygems"
+require "#{direc}/../lib/local_eval"
+require 'mult'
+
+C = Object.new
+class << C
+  def hello
+    capture { @hello = :captures
+    }
+    @goodbye = :captured
+  end
+end
+
+# C.local_eval { hello }
+# C.hello
+# puts @goodbye
+
+o = Object.new
+o.instance_eval {
+  C.local_eval { hello }
+  puts @goodbye
+  puts C.instance_variable_get(:@hello)
+  #  puts @hello
+  puts self.object_id
+}

data/test/test_segfault2.rb

@@ -0,0 +1,8 @@
+require 'remix'
+require 'mult'
+require 'object2module'
+
+o = Object.new
+o.gen_extend Module.new.singleton_class
+puts o.singleton_class.ancestors
+o.singleton_class.ready_remix

data/test/test_segfault_flymake.rb

@@ -0,0 +1,25 @@
+direc = File.dirname(__FILE__)
+require "rubygems"
+require "#{direc}/../lib/local_eval"
+require 'mult'
+
+class C
+  attr_reader :hello
+  def self.hello
+    capture { @hello = :captures }
+    @goodbye = :captured
+  end
+end
+
+C.local_eval { hello }
+@goodbye
+C.hello
+m = Module.new
+m.gen_include Module.new.singleton_class
+
+o = Object.new
+o.instance_eval {
+#  o.actual_class = C
+  self.temp_extend(m) { puts self 
+#  C.local_eval { puts self }
+}

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - John Mair (banisterfiend)
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-15 00:00:00 +13:00
+date: 2010-11-16 00:00:00 +13:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,8 +28,8 @@ dependencies:
         segments: 
         - 0
         - 4
-        - 8
-        version: 0.4.8
+        - 9
+        version: 0.4.9
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -43,8 +43,8 @@ dependencies:
         segments: 
         - 0
         - 4
-        - 3
-        version: 0.4.3
+        - 5
+        version: 0.4.5
   type: :runtime
   version_requirements: *id002
 description: instance_eval without changing self
@@ -59,12 +59,18 @@ files:
 - lib/local_eval/version.rb
 - lib/local_eval/version_flymake.rb
 - lib/local_eval.rb
+- lib/local_eval_flymake.rb
 - test/helper1.rb
+- test/helper1_flymake.rb
 - test/test.rb
+- test/test_flymake.rb
+- test/test_segfault.rb
+- test/test_segfault2.rb
+- test/test_segfault_flymake.rb
 - CHANGELOG
 - README.markdown
 - Rakefile
-has_rdoc: yard
+has_rdoc: true
 homepage: http://banisterfiend.wordpress.com
 licenses: []