serializable_proc 0.1.1 → 0.2.0

data/spec/proc_like/extras_spec.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe 'Extra functionalities' do
+
+  describe '>> to_sexp (empty proc)' do
+
+    before do
+      @s_proc = SerializableProc.new{}
+      @expected = {
+        :extracted => s(:iter, s(:call, nil, :proc, s(:arglist)), nil),
+        :runnable => s(:iter, s(:call, nil, :proc, s(:arglist)), nil)
+      }
+    end
+
+    should 'return sexp representation of extracted code w debug unspecified' do
+      @s_proc.to_sexp.should.equal(@expected[:extracted])
+    end
+
+    should 'return sexp representation of extracted code w debug as false' do
+      @s_proc.to_sexp(false).should.equal(@expected[:extracted])
+    end
+
+    should 'return sexp representation of extracted code w debug as true' do
+      @s_proc.to_sexp(true).should.equal(@expected[:runnable])
+    end
+
+  end
+
+  describe '>> to_sexp (single statement proc)' do
+
+    before do
+      @s_proc = SerializableProc.new{ @x }
+      @expected = {
+        :extracted => s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:ivar, :@x)),
+        :runnable => s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:lvar, :ivar_x))
+      }
+    end
+
+    should 'return sexp representation of extracted code w debug unspecified' do
+      @s_proc.to_sexp.should.equal(@expected[:extracted])
+    end
+
+    should 'return sexp representation of extracted code w debug as false' do
+      @s_proc.to_sexp(false).should.equal(@expected[:extracted])
+    end
+
+    should 'return sexp representation of extracted code w debug as true' do
+      @s_proc.to_sexp(true).should.equal(@expected[:runnable])
+    end
+
+  end
+
+  describe '>> to_sexp (multi statements proc)' do
+
+    before do
+      @s_proc = SerializableProc.new do
+        @a = 1
+        @b = 2
+      end
+      @expected = {
+        :extracted => s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:block,
+          s(:iasgn, :@a, s(:lit, 1)), s(:iasgn, :@b, s(:lit, 2)))),
+        :runnable => s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:block,
+          s(:lasgn, :ivar_a, s(:lit, 1)), s(:lasgn, :ivar_b, s(:lit, 2))))
+      }
+    end
+
+    should 'return sexp representation of extracted code w debug unspecified' do
+      @s_proc.to_sexp.should.equal(@expected[:extracted])
+    end
+
+    should 'return sexp representation of extracted code w debug as false' do
+      @s_proc.to_sexp(false).should.equal(@expected[:extracted])
+    end
+
+    should 'return sexp representation of extracted code w debug as true' do
+      @s_proc.to_sexp(true).should.equal(@expected[:runnable])
+    end
+
+  end
+
+end

data/spec/proc_like/invoking_with_args_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+[:[], :call].each do |invoke|
+  describe "Invoking with args using :#{invoke}" do
+
+    describe '>> wo specified binding' do
+
+      should 'return yield result given no arg' do
+        s_proc = SerializableProc.new { %w{b c}.map{|x| x } }
+        s_proc.send(invoke).should.equal(%w{b c})
+      end
+
+      should 'return yield result given single arg' do
+        s_proc = SerializableProc.new {|i| %w{b c}.map{|x| x*i } }
+        s_proc.send(invoke, 2).should.equal(%w{bb cc})
+      end
+
+      should 'return yield result given optional args' do
+        s_proc = SerializableProc.new {|*args| %w{b c}.map{|x| [x,args].flatten.join } }
+        s_proc.send(invoke, '1', '2').should.equal(%w{b12 c12})
+      end
+
+      should 'return yield result given multiple args' do
+        s_proc = SerializableProc.new {|i, j| %w{b c}.map{|x| x*i*j } }
+        s_proc.send(invoke, 2, 3).should.equal(%w{bbbbbb cccccc})
+      end
+
+    end
+
+    describe '>> w specified binding' do
+
+      should 'return yield result given no arg' do
+        x = 'a'
+        s_proc = SerializableProc.new { %w{b c}.map{|x| x } }
+        s_proc.send(invoke, binding).should.equal(%w{b c})
+      end
+
+      should 'return yield result given single arg' do
+        x = 'a'
+        s_proc = SerializableProc.new {|i| %w{b c}.map{|x| x*i } }
+        s_proc.send(invoke, 2, binding).should.equal(%w{bb cc})
+      end
+
+      should 'return yield result given optional args' do
+        x = 'a'
+        s_proc = SerializableProc.new {|*args| %w{b c}.map{|x| [x,args].flatten.join } }
+        s_proc.send(invoke, '1', '2', binding).should.equal(%w{b12 c12})
+      end
+
+      should 'return yield result given multiple args' do
+        x = 'a'
+        s_proc = SerializableProc.new {|i, j| %w{b c}.map{|x| x*i*j } }
+        s_proc.send(invoke, 2, 3, binding).should.equal(%w{bbbbbb cccccc})
+      end
+
+    end
+  end
+end

data/spec/proc_like/invoking_with_class_vars_spec.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+[:[], :call].each do |invoke|
+  describe "Invoking with class vars using :#{invoke}" do
+
+    describe '>> (w isolation)' do
+
+      should 'not be affected by out-of-scope changes when wo specified binding' do
+        @@x, @@y = 'awe', 'some'
+        s_proc = SerializableProc.new { @@x.sub!('awe','hand'); @@x + @@y }
+        @@x, @@y = 'wonder', 'ful'
+        s_proc.send(invoke).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes when wo specified binding' do
+        @@x, @@y = 'awe', 'some'
+        s_proc = SerializableProc.new { @@x.sub!('awe','hand'); @@x + @@y }
+        @@x, @@y = 'wonder', 'ful'
+        s_proc.send(invoke)
+        @@x.should.equal('wonder')
+      end
+
+      should 'not be affected by out-of-scope changes even when w specified binding' do
+        @@x, @@y = 'awe', 'some'
+        s_proc = SerializableProc.new { @@x.sub!('awe','hand'); @@x + @@y }
+        @@x, @@y = 'wonder', 'ful'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes even when w specified binding' do
+        @@x, @@y = 'awe', 'some'
+        s_proc = SerializableProc.new { @@x.sub!('awe','hand'); @@x + @@y }
+        @@x, @@y = 'wonder', 'ful'
+        s_proc.send(invoke, binding)
+        @@x.should.equal('wonder')
+      end
+
+    end
+
+    describe '>> (wo isolation)' do
+
+      if RUBY_VERSION.include?('1.9.')
+
+        should 'raise NameError when wo specified binding' do
+          @@x, @@y = 'wonder', 'ful'
+          s_proc = SerializableProc.new do
+            @@_not_isolated_vars = :class
+            @@x.sub!('awe','hand')
+            @@x + @@y
+          end
+          @@x, @@y = 'awe', 'some'
+          lambda { s_proc.send(invoke) }.should.raise(NameError)
+        end
+
+      else
+
+        should 'reflect out-of-scope vars even when wo specified binding' do
+          @@x, @@y = 'wonder', 'ful'
+          s_proc = SerializableProc.new do
+            @@_not_isolated_vars = :class
+            @@x.sub!('awe','hand')
+            @@x + @@y
+          end
+          @@x, @@y = 'awe', 'some'
+          s_proc.send(invoke).should.equal('handsome')
+        end
+
+      end
+
+      should 'be affected by out-of-scope changes w specified binding' do
+        @@x, @@y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :class
+          @@x.sub!('awe','hand')
+          @@x + @@y
+        end
+        @@x, @@y = 'awe', 'some'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'effect out-of-scope changes w specified binding' do
+        @@x, @@y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :class
+          @@x.sub!('awe','hand')
+          @@x + @@y
+        end
+        @@x, @@y = 'awe', 'some'
+        s_proc.send(invoke, binding)
+        @@x.should.equal('hand')
+      end
+
+    end
+
+  end
+end

data/spec/proc_like/invoking_with_global_vars_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+[:[], :call].each do |invoke|
+  describe "Invoking with global vars using :#{invoke}" do
+
+    describe '>> (w isolation)' do
+
+      should 'not be affected by out-of-scope changes when wo specified binding' do
+        $x, $y = 'awe', 'some'
+        s_proc = SerializableProc.new { $x.sub!('awe','hand'); $x + $y }
+        $x, $y = 'wonder', 'ful'
+        s_proc.send(invoke).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes when wo specified binding' do
+        $x, $y = 'awe', 'some'
+        s_proc = SerializableProc.new { $x.sub!('awe','hand'); $x + $y }
+        $x, $y = 'wonder', 'ful'
+        s_proc.send(invoke)
+        $x.should.equal('wonder')
+      end
+
+      should 'not be affected by out-of-scope changes even when w specified binding' do
+        $x, $y = 'awe', 'some'
+        s_proc = SerializableProc.new { $x.sub!('awe','hand'); $x + $y }
+        $x, $y = 'wonder', 'ful'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes even when w specified binding' do
+        $x, $y = 'awe', 'some'
+        s_proc = SerializableProc.new { $x.sub!('awe','hand'); $x + $y }
+        $x, $y = 'wonder', 'ful'
+        s_proc.send(invoke, binding)
+        $x.should.equal('wonder')
+      end
+
+    end
+
+    describe '>> (wo isolation)' do
+
+      should 'reflect out-of-scope vars even when wo specified binding' do
+        $x, $y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :global
+          $x.sub!('awe','hand')
+          $x + $y
+        end
+        $x, $y = 'awe', 'some'
+        s_proc.send(invoke).should.equal('handsome')
+      end
+
+      should 'be affected by out-of-scope changes w specified binding' do
+        $x, $y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :global
+          $x.sub!('awe','hand')
+          $x + $y
+        end
+        $x, $y = 'awe', 'some'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'effect out-of-scope changes w specified binding' do
+        $x, $y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :global
+          $x.sub!('awe','hand')
+          $x + $y
+        end
+        $x, $y = 'awe', 'some'
+        s_proc.send(invoke, binding)
+        $x.should.equal('hand')
+      end
+
+    end
+
+  end
+end

data/spec/proc_like/invoking_with_instance_vars_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+[:[], :call].each do |invoke|
+  describe "Invoking with instance vars using :#{invoke}" do
+
+    describe '>> (w isolation)' do
+
+      should 'not be affected by out-of-scope changes when wo specified binding' do
+        @x, @y = 'awe', 'some'
+        s_proc = SerializableProc.new { @x.sub!('awe','hand'); @x + @y }
+        @x, @y = 'wonder', 'ful'
+        s_proc.send(invoke).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes when wo specified binding' do
+        @x, @y = 'awe', 'some'
+        s_proc = SerializableProc.new { @x.sub!('awe','hand'); @x + @y }
+        @x, @y = 'wonder', 'ful'
+        s_proc.send(invoke)
+        @x.should.equal('wonder')
+      end
+
+      should 'not be affected by out-of-scope changes even when w specified binding' do
+        @x, @y = 'awe', 'some'
+        s_proc = SerializableProc.new { @x.sub!('awe','hand'); @x + @y }
+        @x, @y = 'wonder', 'ful'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes even when w specified binding' do
+        @x, @y = 'awe', 'some'
+        s_proc = SerializableProc.new { @x.sub!('awe','hand'); @x + @y }
+        @x, @y = 'wonder', 'ful'
+        s_proc.send(invoke, binding)
+        @x.should.equal('wonder')
+      end
+
+    end
+
+    describe '>> (wo isolation)' do
+
+      should 'raise NameError when wo specified binding' do
+        @x, @y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :instance
+          @x.sub!('awe','hand')
+          @x + @y
+        end
+        @x, @y = 'awe', 'some'
+        lambda { s_proc.send(invoke) }.should.raise(NameError)
+      end
+
+      should 'be affected by out-of-scope changes w specified binding' do
+        @x, @y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :instance
+          @x.sub!('awe','hand')
+          @x + @y
+        end
+        @x, @y = 'awe', 'some'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'effect out-of-scope changes w specified binding' do
+        @x, @y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :instance
+          @x.sub!('awe','hand')
+          @x + @y
+        end
+        @x, @y = 'awe', 'some'
+        s_proc.send(invoke, binding)
+        @x.should.equal('hand')
+      end
+
+    end
+
+  end
+end

data/spec/proc_like/invoking_with_local_vars_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+[:[], :call].each do |invoke|
+  describe "Invoking with local vars using :#{invoke}" do
+
+    describe '>> (w isolation)' do
+
+      should 'not be affected by out-of-scope changes when wo specified binding' do
+        x, y = 'awe', 'some'
+        s_proc = SerializableProc.new { x.sub!('awe','hand'); x + y }
+        x, y = 'wonder', 'ful'
+        s_proc.send(invoke).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes when wo specified binding' do
+        x, y = 'awe', 'some'
+        s_proc = SerializableProc.new { x.sub!('awe','hand'); x + y }
+        x, y = 'wonder', 'ful'
+        s_proc.send(invoke)
+        x.should.equal('wonder')
+      end
+
+      should 'not be affected by out-of-scope changes even when w specified binding' do
+        x, y = 'awe', 'some'
+        s_proc = SerializableProc.new { x.sub!('awe','hand'); x + y }
+        x, y = 'wonder', 'ful'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'not effect out-of-scope changes even when w specified binding' do
+        x, y = 'awe', 'some'
+        s_proc = SerializableProc.new { x.sub!('awe','hand'); x + y }
+        x, y = 'wonder', 'ful'
+        s_proc.send(invoke, binding)
+        x.should.equal('wonder')
+      end
+
+    end
+
+    describe '>> (wo isolation)' do
+
+      should 'raise NameError when wo specified binding' do
+        x, y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :local
+          x.sub!('awe','hand')
+          x + y
+        end
+        x, y = 'awe', 'some'
+        lambda { s_proc.send(invoke) }.should.raise(NameError)
+      end
+
+      should 'be affected by out-of-scope changes w specified binding' do
+        x, y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :local
+          x.sub!('awe','hand')
+          x + y
+        end
+        x, y = 'awe', 'some'
+        s_proc.send(invoke, binding).should.equal('handsome')
+      end
+
+      should 'effect out-of-scope changes w specified binding' do
+        x, y = 'wonder', 'ful'
+        s_proc = SerializableProc.new do
+          @@_not_isolated_vars = :local
+          x.sub!('awe','hand')
+          x + y
+        end
+        x, y = 'awe', 'some'
+        s_proc.send(invoke, binding)
+        x.should.equal('hand')
+      end
+
+    end
+
+  end
+end

data/spec/{marshalling_spec.rb → proc_like/marshalling_spec.rb}

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe 'Marshalling' do
 

data/spec/proc_like/others_spec.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe 'Being proc like' do
+
+  describe '>> ==' do
+
+    before do
+      @proc = SerializableProc.new{ %w{a b}.map{|x| x } }
+    end
+
+    should 'return true if comparing to itself' do
+      @proc.should.equal(@proc)
+    end
+
+    should 'return true if another SerializableProc has the same code' do
+      SerializableProc.new{ %w{a b}.map{|x| x } }.should.equal(@proc)
+    end
+
+    should 'return false if another SerializableProc does not have the same code' do
+      SerializableProc.new{ %w{b c}.map{|x| x } }.should.not.equal(@proc)
+    end
+
+  end
+
+  describe '>> clone' do
+    should 'return a serializable proc that yields +ve ==' do
+      s_proc = SerializableProc.new { %w{b c}.map{|x| x } }
+      clone = s_proc.clone
+      clone.should.equal(s_proc)
+      clone.object_id.should.not.equal(s_proc.object_id)
+    end
+  end
+
+  describe '>> to_proc' do
+
+    class << self
+      def work(&block) ; yield ; end
+    end
+
+    should 'return a non-serializable proc' do
+      o_proc = lambda { %w{b c}.map{|x| x } }
+      s_proc = SerializableProc.new(&o_proc)
+      n_proc = s_proc.to_proc
+      s_proc.should.not == n_proc
+      n_proc.class.should == Proc
+      n_proc.call.should.equal(o_proc.call)
+    end
+
+    should "support passing to a method using '&' char" do
+      s_proc = SerializableProc.new { %w{b c}.map{|x| x } }
+      work(&s_proc).should.equal(%w{b c})
+    end
+
+  end
+
+  describe '>> to_s' do
+    extend SerializableProc::Spec::Helpers
+
+    should 'return extracted code when debug is unspecified' do
+      x, @x, @@x, $x = 'lx', 'ix', 'cx', 'gx'
+      SerializableProc.new{ [x,@x,@@x,$x] }.to_s.should.be \
+        having_same_semantics_as('lambda { [x, @x, @@x, $x] }')
+    end
+
+    should 'return extracted code w debug as false' do
+      x, @x, @@x, $x = 'lx', 'ix', 'cx', 'gx'
+      SerializableProc.new{ [x,@x,@@x,$x] }.to_s(false).should.be \
+        having_same_semantics_as('lambda { [x, @x, @@x, $x] }')
+    end
+
+    should 'return runnable code w debug as true' do
+      x, @x, @@x, $x = 'lx', 'ix', 'cx', 'gx'
+      SerializableProc.new{ [x,@x,@@x,$x] }.to_s(true).should.be \
+        having_same_semantics_as('lambda { [lvar_x, ivar_x, cvar_x, gvar_x] }')
+    end
+  end
+
+  describe '>> arity' do
+    {
+      __LINE__ => lambda { },
+      __LINE__ => lambda {|x| },
+      __LINE__ => lambda {|x,y| },
+      __LINE__ => lambda {|*x| },
+      __LINE__ => lambda {|x, *y| },
+      __LINE__ => lambda {|(x,y)| },
+    }.each do |debug, block|
+      should "return arity of initializing block [##{debug}]" do
+        SerializableProc.new(&block).arity.should.equal(block.arity)
+      end
+    end
+  end
+
+  describe '>> binding' do
+    should 'raise NotImplementedError' do
+      lambda { SerializableProc.new { x }.binding }.should.raise(NotImplementedError)
+    end
+    # should 'return binding that contains duplicated contextual reference values' do
+    #   x, @x, @@x, $x = 'lx', 'ix', 'cx', 'gx'
+    #   expected = {'x' => x.dup, '@x' => @x.dup, '@@x' => @@x.dup, '$x' => $x.dup}
+    #   s_proc = SerializableProc.new { [x, @x, @@x, $x] }
+    #   x, @x, @@x, $x = 'ly', 'iy', 'cy', 'gy'
+    #   expected.each{|k,v| s_proc.binding.eval(k).should.equal(v) }
+    # end
+  end
+
+end

data/spec/spec_helper.rb

@@ -39,6 +39,12 @@ class SerializableProc
         lambda {|code1| normalize[code1].should.equal(normalize[code2]) }
       end
 
+      def having_runnable_code_as(code)
+        lambda do |s_proc|
+          s_proc.code[:runnable].should.be having_same_semantics_as(code)
+        end
+      end
+
       def same_object_as(o2)
         lambda {|o1| o1.object_id == o2.object_id }
       end
@@ -78,6 +84,10 @@ class SerializableProc
         end
       end
 
+      def should_have_empty_binding(s_proc)
+        s_proc.binding_dump.should.be.empty
+      end
+
       def should_handle_proc_variable(file, code, test_args)
         test_args.each do |line, block|
           should "handle proc variable [##{line}]" do