serializable_proc 0.1.0

data/spec/one_arity_serializable_proc_spec.rb

@@ -0,0 +1,159 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'One arity serializable proc' do
+
+  extend SerializableProc::Spec::Helpers
+
+  expected_file = File.expand_path(__FILE__)
+  expected_code = "lambda { |lvar_arg| [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
+
+  should_handle_proc_variable expected_file, expected_code, {
+    # ////////////////////////////////////////////////////////////////////////
+    # >> Always newlinling
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ =>
+        lambda do |arg|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end,
+      __LINE__ =>
+        lambda { |arg|
+          %w{a b}.map{|x|
+            puts x
+          }
+        },
+      __LINE__ =>
+        proc do |arg|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end,
+      __LINE__ =>
+        lambda { |arg|
+          %w{a b}.map{|x|
+            puts x
+          }
+        },
+      __LINE__ =>
+        Proc.new do |arg|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end,
+      __LINE__ =>
+        Proc.new { |arg|
+          %w{a b}.map{|x|
+            puts x
+          }
+        },
+    # ////////////////////////////////////////////////////////////////////////
+    # >> Partial newlining
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ =>
+        lambda do |arg|
+          %w{a b}.map do |x| puts x end
+        end,
+      __LINE__ =>
+        lambda { |arg|
+          %w{a b}.map{|x| puts x }
+        },
+      __LINE__ =>
+        proc do |arg|
+          %w{a b}.map do |x| puts x end
+        end,
+      __LINE__ =>
+        lambda { |arg|
+          %w{a b}.map{|x| puts x }
+        },
+      __LINE__ =>
+        Proc.new do |arg|
+          %w{a b}.map do |x| puts x end
+        end,
+      __LINE__ =>
+        Proc.new { |arg|
+          %w{a b}.map{|x| puts x }
+        },
+    # ////////////////////////////////////////////////////////////////////////
+    # >> No newlining
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ =>
+        lambda do |arg| %w{a b}.map do |x| puts x end end,
+      __LINE__ =>
+        lambda { |arg| %w{a b}.map{|x| puts x } },
+      __LINE__ =>
+        proc do |arg| %w{a b}.map do |x| puts x end end,
+      __LINE__ =>
+        lambda { |arg| %w{a b}.map{|x| puts x } },
+      __LINE__ =>
+        Proc.new do |arg| %w{a b}.map do |x| puts x end end,
+      __LINE__ =>
+        Proc.new { |arg| %w{a b}.map{|x| puts x } },
+    }
+
+  should "handle block using do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new do |arg|
+        %w{a b}.map{|x| puts x }
+      end
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle block using do ... end [##{__LINE__}]" do
+    (SerializableProc.new do |arg| %w{a b}.map{|x| puts x } end).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle block using { ... } [##{__LINE__}]" do
+    (
+      SerializableProc.new { |arg|
+        %w{a b}.map{|x| puts x }
+      }
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle block using { ... } [##{__LINE__}]" do
+    (SerializableProc.new { |arg| %w{a b}.map{|x| puts x } }).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
+    (SerializableProc.new(&(lambda { |arg| %w{a b}.map{|x| puts x } }))).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new(&(lambda do |arg|
+        %w{a b}.map{|x| puts x }
+      end))
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
+    (SerializableProc.new(&(proc { |arg| %w{a b}.map{|x| puts x } }))).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new(&(proc do |arg|
+        %w{a b}.map{|x| puts x }
+      end))
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
+    (SerializableProc.new(&(Proc.new { |arg| %w{a b}.map{|x| puts x } }))).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new(&(Proc.new do |arg|
+        %w{a b}.map{|x| puts x }
+      end))
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+end

data/spec/optional_arity_serializable_proc_spec.rb

@@ -0,0 +1,160 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'Optional arity serializable proc' do
+
+  extend SerializableProc::Spec::Helpers
+
+  expected_file = File.expand_path(__FILE__)
+  expected_code = "lambda { |*lvar_args| [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
+
+  should_handle_proc_variable expected_file, expected_code, {
+    # ////////////////////////////////////////////////////////////////////////
+    # >> Always newlinling
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ =>
+        lambda do |*args|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end,
+      __LINE__ =>
+        lambda { |*args|
+          %w{a b}.map{|x|
+            puts x
+          }
+        },
+      __LINE__ =>
+        proc do |*args|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end,
+      __LINE__ =>
+        lambda { |*args|
+          %w{a b}.map{|x|
+            puts x
+          }
+        },
+      __LINE__ =>
+        Proc.new do |*args|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end,
+      __LINE__ =>
+        Proc.new { |*args|
+          %w{a b}.map{|x|
+            puts x
+          }
+        },
+    # ////////////////////////////////////////////////////////////////////////
+    # >> Partial newlining
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ =>
+        lambda do |*args|
+          %w{a b}.map do |x| puts x end
+        end,
+      __LINE__ =>
+        lambda { |*args|
+          %w{a b}.map{|x| puts x }
+        },
+      __LINE__ =>
+        proc do |*args|
+          %w{a b}.map do |x| puts x end
+        end,
+      __LINE__ =>
+        lambda { |*args|
+          %w{a b}.map{|x| puts x }
+        },
+      __LINE__ =>
+        Proc.new do |*args|
+          %w{a b}.map do |x| puts x end
+        end,
+      __LINE__ =>
+        Proc.new { |*args|
+          %w{a b}.map{|x| puts x }
+        },
+    # ////////////////////////////////////////////////////////////////////////
+    # >> No newlining
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ =>
+        lambda do |*args| %w{a b}.map do |x| puts x end end,
+      __LINE__ =>
+        lambda { |*args| %w{a b}.map{|x| puts x } },
+      __LINE__ =>
+        proc do |*args| %w{a b}.map do |x| puts x end end,
+      __LINE__ =>
+        lambda { |*args| %w{a b}.map{|x| puts x } },
+      __LINE__ =>
+        Proc.new do |*args| %w{a b}.map do |x| puts x end end,
+      __LINE__ =>
+        Proc.new { |*args| %w{a b}.map{|x| puts x } },
+    }
+
+  should "handle block using do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new do |*args|
+        %w{a b}.map{|x| puts x }
+      end
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle block using do ... end [##{__LINE__}]" do
+    (SerializableProc.new do |*args| %w{a b}.map{|x| puts x } end).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle block using { ... } [##{__LINE__}]" do
+    (
+      SerializableProc.new { |*args|
+        %w{a b}.map{|x| puts x }
+      }
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle block using { ... } [##{__LINE__}]" do
+    (SerializableProc.new { |*args| %w{a b}.map{|x| puts x } }).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
+    (SerializableProc.new(&(lambda { |*args| %w{a b}.map{|x| puts x } }))).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new(&(lambda do |*args|
+        %w{a b}.map{|x| puts x }
+      end))
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
+    (SerializableProc.new(&(proc { |*args| %w{a b}.map{|x| puts x } }))).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new(&(proc do |*args|
+        %w{a b}.map{|x| puts x }
+      end))
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+  should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
+    (SerializableProc.new(&(Proc.new { |*args| %w{a b}.map{|x| puts x } }))).
+      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
+  end
+
+  should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
+    (
+      SerializableProc.new(&(Proc.new do |*args|
+        %w{a b}.map{|x| puts x }
+      end))
+    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
+  end
+
+
+end

data/spec/proc_like_spec.rb

@@ -0,0 +1,191 @@
+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 '>> call (alias [])' do
+
+    should 'return yield result given no arg' do
+      s_proc = SerializableProc.new { %w{b c}.map{|x| x } }
+      expected = %w{b c}
+      s_proc.call.should.equal(expected)
+      s_proc[].should.equal(expected)
+    end
+
+    should 'reflect bound instance variable value (unaffected by outside-scope change)' do
+      x, y = 'awe', 'some'
+      expected = 'hand' + y
+      s_proc = SerializableProc.new { x.sub!('awe','hand'); x + y }
+      x, y = 'wonder', 'ful'
+      s_proc.call.should.equal(expected)
+      s_proc[].should.equal(expected)
+    end
+
+    should 'not affect any outside-scope change to instance variable' do
+      x, y = 'awe', 'some'
+      s_proc = SerializableProc.new { x.sub!('awe','hand'); x + y }
+      x, y = 'wonder', 'ful'
+      s_proc.call ; s_proc[]
+      x.should.equal('wonder')
+      y.should.equal('ful')
+    end
+
+    should 'reflect bound instance variable value (unaffected by outside-scope change)' do
+      @x, @y = 'awe', 'some'
+      expected = 'hand' + @y
+      s_proc = SerializableProc.new { @x.sub!('awe','hand'); @x + @y }
+      @x, @y = 'wonder', 'ful'
+      s_proc.call.should.equal(expected)
+      s_proc[].should.equal(expected)
+    end
+
+    should 'not affect any outside-scope change to instance variable' do
+      @x, @y = 'awe', 'some'
+      s_proc = SerializableProc.new { @x.sub!('awe','hand'); @x + @y }
+      @x, @y = 'wonder', 'ful'
+      s_proc.call ; s_proc[]
+      @x.should.equal('wonder')
+      @y.should.equal('ful')
+    end
+
+    should 'reflect bound class variable value (unaffected by outside-scope change)' do
+      @@x, @@y = 'awe', 'some'
+      expected = 'hand' + @@y
+      s_proc = SerializableProc.new { @@x.sub!('awe','hand'); @@x + @@y }
+      @@x, @@y = 'wonder', 'ful'
+      s_proc.call.should.equal(expected)
+      s_proc[].should.equal(expected)
+    end
+
+    should 'not affect any outside-scope change to class variable' do
+      @@x, @@y = 'awe', 'some'
+      s_proc = SerializableProc.new { @@x.sub!('awe','hand'); @@x + @@y }
+      @@x, @@y = 'wonder', 'ful'
+      s_proc.call ; s_proc[]
+      @@x.should.equal('wonder')
+      @@y.should.equal('ful')
+    end
+
+    should 'reflect bound global variable value (unaffected by outside-scope change)' do
+      $x, $y = 'awe', 'some'
+      expected = 'hand' + $y
+      s_proc = SerializableProc.new { $x.sub!('awe','hand'); $x + $y }
+      $x, $y = 'wonder', 'ful'
+      s_proc.call.should.equal(expected)
+      s_proc[].should.equal(expected)
+    end
+
+    should 'not affect any outside-scope change to global variable' do
+      $x, $y = 'awe', 'some'
+      s_proc = SerializableProc.new { $x.sub!('awe','hand'); $x + $y }
+      $x, $y = 'wonder', 'ful'
+      s_proc.call ; s_proc[]
+      $x.should.equal('wonder')
+      $y.should.equal('ful')
+    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 '>> 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
+
+  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 not specified' 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 when debug is turned off' 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 when debug is turned on' 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
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'bacon'
+require 'tempfile'
+require 'ruby2ruby'
+
+$parse_tree_installed =
+  begin
+    require 'parse_tree'
+    true
+  rescue LoadError
+    require 'ruby_parser'
+    nil
+  end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'serializable_proc'
+
+Bacon.summary_on_exit
+
+class SerializableProc
+
+  attr_reader :code, :file, :line
+
+  def binding_dump
+    @binding.instance_variable_get(:@vars)
+  end
+
+  module Spec
+
+    module Matchers
+
+      def having_same_semantics_as(code2)
+        to_code = lambda{|sexp| ::Ruby2Ruby.new.process(sexp) }
+        to_sexp = $parse_tree_installed ?
+          lambda{|code| Unifier.new.process(::ParseTree.translate(code)) } :
+          lambda{|code| ::RubyParser.new.parse(code) }
+        normalize = lambda{|code| to_code[to_sexp[code]].sub('lambda','proc') }
+        lambda {|code1| normalize[code1].should.equal(normalize[code2]) }
+      end
+
+      def same_object_as(o2)
+        lambda {|o1| o1.object_id == o2.object_id }
+      end
+
+      def having_expected_proc_attrs(file, line, code)
+        lambda do |s_proc|
+          s_proc.code[:runnable].should.be having_same_semantics_as(code)
+          s_proc.file.should.equal(file)
+          s_proc.line.should.equal(line)
+        end
+      end
+
+      def raising_cannot_serialize_variable_error(var)
+        lambda do |block|
+          block.should.raise(SerializableProc::CannotSerializeVariableError).
+            message.should.equal('Variable %s cannot be serialized !!' % var)
+          true
+        end
+      end
+
+      def raising_cannot_analyse_error(descrp)
+        lambda do |block|
+          block.should.raise(SerializableProc::CannotAnalyseCodeError).message.should.
+          equal("Static code analysis can only handle single occurrence of #{descrp} per line !!")
+          true
+        end
+      end
+
+    end
+
+    module Macros
+
+      def should_have_expected_binding(s_proc, expected)
+        s_proc.binding_dump.should.equal(expected)
+        expected.each do |key, val|
+          (s_proc.binding_dump[key].should.not.be same_object_as(val)) if val
+        end
+      end
+
+      def should_handle_proc_variable(file, code, test_args)
+        test_args.each do |line, block|
+          should "handle proc variable [##{line}]" do
+            s_proc = SerializableProc.new(&block)
+            s_proc.code[:runnable].should.be having_same_semantics_as(code)
+            s_proc.file.should.equal(file)
+            s_proc.line.should.equal(line.succ)
+          end
+        end
+      end
+
+    end
+
+    module Helpers
+      include Macros
+      include Matchers
+    end
+
+  end
+end