serializable_proc 0.3.1 → 0.4.0

data/HISTORY.txt

@@ -1,4 +1,8 @@
-===  0.3.1 (Aug 18, 2010)
+=== 0.4.0 (Sep 10, 2010)
+
+* code extraction is now delegated to more well-tested & robust sourcify [#ngty]
+
+=== 0.3.1 (Aug 18, 2010)
 
 * @@_not_isolated_vars now supports :all, which is an alias of :global + :local +
   :instance + :class [#ngty]

data/README.rdoc

@@ -4,7 +4,7 @@ As the name suggests, SerializableProc is a proc that can be serialized (marshal
 A proc is a closure, which consists of the code block defining it, and binding of
 local variables. SerializableProc's approach to serializability is to extract:
 
-1. the code from the proc (using ParseTree or RubyParser), and
+1. the code from the proc (using sourcify), and
 2. the local, instance, class & global variables reference within the proc from the
    proc's binding, using deep copy via Marshal.load(Marshal.dump(var))
 
@@ -63,137 +63,20 @@ No throwing of TypeError when marshalling a SerializableProc:
 
 The religiously standard way:
 
-  $ gem install ParseTree serializable_proc
-
-Or on 1.9.* or JRuby:
-
-  $ gem install ruby_parser serializable_proc
-
-By default, SerializableProc attempts to load ParseTree, which supports better
-performance & offers many dynamic goodness. If ParseTree cannot be found,
-SerializableProc falls back to the RubyParser-based which suffers some gotchas due
-to its static analysis nature (see 'Gotchas' section).
-
-== Performance
-
-SerializableProc relies on ParseTree or RubyParser to do code extraction. While running
-in ParseTree mode, thanks to the goodness of dynamic code analysis, SerializableProc
-performs faster by a magnitude of abt 6 times for the same ruby, as illustrated with
-the following benchmark results:
-
-  MRI & implementation    user      system    total      real
-  1.8.7p299 (ParseTree)   0.000000  0.000000  3.510000   3.660623
-  1.8.7p299 (RubyParser)  0.000000  0.000000  20.780000  21.328566
-  1.9.1p376 (RubyParser)  0.010000  0.000000  16.990000  17.370586
-
-Note:
-* the above are obtained from running the specs suite of 393 specifications with 1330
-  requirements
-* hardware & OS specs: x86_64 Intel(R) Core(TM)2 Duo CPU P8600 @ 2.40GHz
+  $ gem install serializable_proc
 
 == Gotchas
 
-As RubyParser does only static code analysis, quite a bit of regexp matchings are needed
-to get SerializableProc to work in RubyParser mode. However, as our regexp kungfu is not
-perfect (yet), pls take note of the following:
-
-=== 1. Cannot have multiple initializing code block per line
-
-The following initializations throw SerializableProc::CannotAnalyseCodeError:
-
-  # Multiple SerializableProc.new per line
-  SerializableProc.new { ... } ; SerializableProc.new { ... }
-
-  # Multiple lambda per line (the same applies to proc & Proc.new)
-  x_proc = lambda { ... } ; y_proc = lambda { ... }
-  SerializableProc.new(&x_proc)
-
-  # Mixed lambda, proc & Proc.new per line
-  x_proc = proc { ... } ; y_proc = lambda { ... }
-  SerializableProc.new(&x_proc)
-
-=== 2. Limited ways to initialize code blocks
-
-Code block must be initialized with lambda, proc, Proc.new & SerializableProc.new,
-the following will throw SerializableProc::CannotAnalyseCodeError:
-
-  def create_magic_proc(&block)
-    SerializableProc.new(&block)
-  end
-
-  create_magic_proc { ... }
-
-But the following will work as expected:
-
-  x_proc = lambda { ... }
-  create_magic_proc(&x_proc)
-
-There are several strategies to workaround this limitation:
-
-==== 2.1. Subclassing SerializableProc
-
-Any subclass of SerializableProc shows traits of a SerializableProc:
-
-  class MagicProc < SerializableProc ; end
-  m_proc = MagicProc.new { ... } # m_proc walks & quacks like a SerializableProc
-
-==== 2.2. Adding custom matcher(s)
-
-To support more match cases, we can declare new matchers:
-
-  def work(&block)
-    s_proc = SerializableProc.new(&block)
-    ...
-  end
-
-  SerializableProc::Parsers::Static.matchers << 'create_magic_proc'
-  work { ... }
-
-Or if the method above takes arguments:
-
-  def create_magic_proc(*args, &block)
-    s_proc = SerializableProc.new(&block)
-    ...
-  end
-
-  SerializableProc::Parsers::Static.matchers << 'create_magic_proc\W+.*?\W+'
-  create_magic_proc(1, :a => 2, :b => 3) { ... }
-
-=== 3. One liner for ...
-
-This is embarassing, but being flexible can aggrevates performance even more.
-Currently, the declarative (eg. lambda, proc, SerializableProc.new, Proc.new,
-subclasses of SerializableProc, & any user-defined matcher(s)), & the start of
-the code-block (the 'do' & '{' chars) must be on the same line. Meaning the
-following won't work:
-
-  SerializableProc.new \
-    do
-      ...
-    end
-
-  create_magic_proc(
-    1, :a => 2
-  ) { ... }
+Under the hood, SerializableProc relies on sourcify[http://github.com/ngty/sourcify] to
+do code extraction, thus it shares the same gotchas as sourcify.
 
 == Supported Rubies
 
 SerializableProc has been tested to work on the following rubies:
 
 1. MRI 1.8.6, 1.8.7 & 1.9.1
-2. JRuby (partial, the more conservative usages work, quite abit of the specs are failing
-   due to JRuby's bug in dumping a proc's line number when we do Proc#inspect)
-
-== TODO (just brain-dumping)
-
-1. The RubyParser-based implementation probably need alot more optimization to catch up
-   on ParseTree-based one
-2. Implementing alternative means (if possible) of extracting the code block without
-   requiring help of ParseTree or RubyParser
-3. Implement workaround to tackle line-numbering bug in JRuby, which causes the
-   RubyParser-based implementation to fail, for more info abt JRuby's line-numbering
-   bug, see http://stackoverflow.com/questions/3454838/jruby-line-numbering-problem &
-   http://jira.codehaus.org/browse/JRUBY-5014
+2. REE 1.8.7
+2. JRuby 1.5.1+
 
 == Note on Patches/Pull Requests
 

data/Rakefile

@@ -8,39 +8,15 @@ begin
     gem.name = "serializable_proc"
     gem.summary = %Q{Proc that can be serialized (as the name suggests)}
     gem.description = %Q{
-      Give & take, serializing a ruby proc is possible, though not a perfect one.
-      Requires either ParseTree (faster) or RubyParser (& Ruby2Ruby).
+      Give & take, serializing a ruby proc is possible, though not a perfect one (yet).
     }
     gem.email = "ngty77@gmail.com"
     gem.homepage = "http://github.com/ngty/serializable_proc"
     gem.authors = ["NgTzeYang"]
-    gem.add_dependency "ruby2ruby", ">= 1.2.4"
+    gem.add_dependency "sourcify", ">= 0.2.2.1"
+    gem.add_dependency "ruby2ruby", ">= 1.2.5"
+    gem.add_dependency "sexp_processor", ">= 3.0.5"
     gem.add_development_dependency "bacon", ">= 0"
-    # Plus one of the following groups:
-    #
-    # 1). ParseTree (better performance + dynamic goodness, but not supported on java & 1.9.*)
-    # >> gem.add_dependency "ParseTree", ">= 3.0.5"
-    #
-    # 2). RubyParser (supported for all)
-    # >> gem.add_dependency "ruby_parser", ">= 2.0.4"
-
-    unless RUBY_PLATFORM =~ /java/i or RUBY_VERSION.include?('1.9.')
-      gem.post_install_message = %Q{
- /////////////////////////////////////////////////////////////////////////////////
-
-  ** SerializableProc **
-
-  You are installing SerializableProc on a ruby platform & version that supports
-  ParseTree. With ParseTree, u can enjoy better performance of SerializableProc,
-  as well as other dynamic code analysis goodness, as compared to the default
-  implementation using RubyParser's less flexible static code analysis.
-
-  Anyway, u have been informed, SerializableProc will fallback on its default
-  implementation using RubyParser.
-
- /////////////////////////////////////////////////////////////////////////////////
-      }
-    end
   end
 
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/lib/serializable_proc/binding.rb

@@ -9,21 +9,8 @@ class SerializableProc
     marshal_attr :vars
 
     def initialize(binding, sexp)
-      sexp, @vars = sexp.gsub(s(:scope, s(:block, SexpAny.new)), nil), {}
-      types = isolated_types(sexp)
-      unless types.empty?
-        sexp_str = sexp.inspect
-        while m = sexp_str.match(/^(.*?s\(:(?:#{types.join('|')})var, :([^\)]+)\))/)
-          ignore, var = m[1..2]
-          sexp_str.sub!(ignore,'')
-          next unless isolatable?(var)
-          begin
-            val = eval(var, binding) rescue nil
-            @vars.update(isolated_var(var) => mclone(val))
-          rescue TypeError
-            raise CannotSerializeVariableError.new("Variable #{var} cannot be serialized !!")
-          end
-        end
+      @vars = isolatable_vars(sexp).inject({}) do |memo, (o_var, n_var)|
+        memo.merge(n_var => bounded_val(o_var, binding))
       end
     end
 
@@ -45,5 +32,14 @@ class SerializableProc
         @declare_vars ||= @vars.map{|(k,v)| "#{k} = Marshal.load(%|#{mdump(v)}|)" } * '; '
       end
 
+      def bounded_val(var, binding)
+        begin
+          val = eval(var.to_s, binding) rescue nil
+          mclone(val)
+        rescue TypeError
+          raise CannotSerializeVariableError.new("Variable #{var} cannot be serialized !!")
+        end
+      end
+
   end
 end

data/lib/serializable_proc/isolatable.rb

@@ -1,66 +1,83 @@
 class SerializableProc
   module Isolatable
 
+    MAPPERS = {'l' => '', 'c' => '@@', 'i' => '@', 'g' => '$'}
+    ISOLATION_VAR = :@@_not_isolated_vars
+    BLOCK_SCOPES = [:class, :sclass, :defn, :module]
+
     protected
 
-      def isolated_sexp(sexp)
-        eval (types = isolated_types(sexp)).empty? ? sexp.inspect : (
-          bypass_scoping_by_block(sexp) do |sexp_str|
-            # NOTE: for performance issue, we play around with the sexp string, rather
-            # than the actual sexp.
-            isolated_sexp_str_for_typed_vars(sexp_str, types)
+      def isolatable_vars(sexp)
+        sexp = sexp.to_a if sexp.is_a?(Sexp)
+        return if BLOCK_SCOPES.include?(sexp[0])
+        sexp.inject({}) do |memo, e|
+          if e.is_a?(Array)
+            memo.merge(isolatable_vars(e) || {})
+          elsif e.to_s =~ /^((l|c|g|i)var_(\w+))$/
+            memo.merge((MAPPERS[$2] + $3).to_sym => $1.to_sym)
+          else
+            memo
           end
-        )
+        end
       end
 
-      def bypass_scoping_by_block(sexp)
-        tmp_marker = :_serializable_proc_block_scope_marker_
-        s_sexp = sexp.gsub(s(:scope, s(:block, SexpAny.new)), tmp_marker)
-        pattern = %r{^#{Regexp.quote(s_sexp.inspect).gsub(tmp_marker.inspect,'(.*?)')}$}
-        orig_blocks = sexp.inspect.match(pattern)[1..-1] rescue []
-        n_sexp_str = yield(s_sexp.inspect)
-        orig_blocks.inject(n_sexp_str) do |sexp_str, block_sexp_str|
-          sexp_str.sub(tmp_marker.inspect, block_sexp_str)
-        end
+      def isolated_sexp_and_code(sexp)
+        sexp_arry, @types = sexp.to_a, isolated_types(sexp).join('|')
+        sexp_arry = isolated_sexp_arry(sexp_arry) unless @types.empty?
+        [
+          Sexp.from_array(sexp_arry),
+          Ruby2Ruby.new.process(Sexp.from_array(sexp_arry))
+        ]
       end
 
-      def isolated_sexp_str_for_typed_vars(o_sexp_str, types)
-        n_sexp_str = nil
-        var_pattern = /^(.*?s\(:)((#{types.join('|')})(asgn|var|vdecl))(,\ :)((|@|@@|\$)([\w]+))(\)|,)/
+    private
 
-        while m = o_sexp_str.match(var_pattern)
-          orig, prepend, _, type, declare, join, var, _, name, append = m[0..-1]
-          n_sexp_str = isolatable?(var) ?
-            "#{n_sexp_str}#{prepend}l#{declare.sub('vdecl','asgn')}#{join}#{type}var_#{name}#{append}" :
-            "#{n_sexp_str}#{orig}"
-          o_sexp_str.sub!(orig,'')
+      def isolated_types(sexp)
+        if (declarative = isolatable_declarative(sexp)).empty?
+          MAPPERS.keys
+        elsif declarative.include?('all')
+          []
+        else
+          MAPPERS.keys - declarative.map{|e| e[0].chr }
         end
-
-        "#{n_sexp_str}#{o_sexp_str}"
       end
 
-      def isolated_var(var)
-        @translate_var_maps ||= {'@' => 'ivar_', '@@' => 'cvar_', '$' => 'gvar_', '' => 'lvar_'}
-        m = var.to_s.match(/^(|@|@@|\$)(\w+)$/)
-        var.to_s.sub(m[1], @translate_var_maps[m[1]]).to_sym
+      def isolated_sexp_arry(array)
+        return array if BLOCK_SCOPES.include?(array[0])
+        array.map do |e|
+          case e
+          when Array
+            if e.size == 2 && e[0].to_s =~ /^(#{@types})var$/
+              isolatable?(var = e[1]) ? [:lvar, isolated_var(var,$1)] : e
+            elsif e[0].to_s =~ /^(#{@types})(vdel|asgn)$/ && isolatable?(var = e[1])
+              isolated_sexp_arry([:lasgn, isolated_var(var,$1), *e[2..-1]])
+            else
+              isolated_sexp_arry(e)
+            end
+          else
+            e
+          end
+        end
       end
 
-      def isolated_types(sexp)
-        o_sexp_arry = sexp.to_a
-        n_sexp = sexp.gsub(s(:cvdecl, :@@_not_isolated_vars, SexpAny.new), nil)
-        types = %w{global instance local class}
+      def isolated_var(var, type = nil)
+        m = var.to_s.match(/^(\W*)(\w+)$/)[1..2]
+        type ||= MAPPERS.invert[m[0]]
+        :"#{type}var_#{m[1]}"
+      end
 
-        if (diff = o_sexp_arry - n_sexp.to_a).empty?
-          types.map{|t| t[0].chr }
-        else
-          sexp_str = Sexp.from_array(diff).inspect
-          sexp_str.include?("s(:lit, :all)") ? [] :
-            types.map{|t| t[0].chr unless sexp_str.include?("s(:lit, :#{t})") }.compact
+      def isolatable_declarative(sexp)
+        declaratives = []
+        sexp.each_of_type(:cvdecl) do |node|
+          next unless node.to_a[1] == ISOLATION_VAR
+          node.each_of_type(:lit) {|_node| declaratives << _node.to_a[-1].to_s }
+          break
         end
+        declaratives
       end
 
       def isolatable?(var)
-        var != '@@_not_isolated_vars'
+        var.to_s != ISOLATION_VAR.to_s
       end
 
   end

data/lib/serializable_proc.rb

@@ -1,18 +1,12 @@
 require 'rubygems'
 require 'forwardable'
+require 'sourcify'
 require 'ruby2ruby'
+require 'sexp_processor'
+
 require 'serializable_proc/marshalable'
 require 'serializable_proc/isolatable'
-require 'serializable_proc/parsers'
 require 'serializable_proc/binding'
-require 'serializable_proc/fixes'
-
-begin
-  require 'parse_tree'
-  require 'parse_tree_extensions'
-rescue LoadError
-  require 'ruby_parser'
-end
 
 ##
 # SerializableProc differs from the vanilla Proc in 2 ways:
@@ -72,8 +66,9 @@ end
 #
 class SerializableProc
 
+  include Isolatable
   include Marshalable
-  marshal_attrs :file, :line, :code, :arity, :binding, :sexp
+  marshal_attrs :file, :line, :codes, :arity, :binding, :sexps
 
   ##
   # Creates a new instance of SerializableProc by passing in a code block, in the process,
@@ -92,10 +87,12 @@ class SerializableProc
   #   action { ... }
   #
   def initialize(&block)
-    file, line = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+).*?>$/.match(block.inspect)[1..2]
-    @file, @line, @arity = File.expand_path(file), line.to_i, block.arity
-    @code, @sexp = Parsers::Dynamic.process(block) || Parsers::Static.process(self.class, file, @line)
-    @binding = Binding.new(block.binding, @sexp[:extracted])
+    e_code, e_sexp = block.to_source, block.to_sexp
+    r_sexp, r_code = isolated_sexp_and_code(e_sexp)
+    @arity, @file, @line = block.arity, *block.source_location
+    @codes = {:extracted => e_code, :runnable => r_code}
+    @sexps = {:extracted => e_sexp, :runnable => r_sexp}
+    @binding = Binding.new(block.binding, r_sexp)
   end
 
   ##
@@ -132,9 +129,9 @@ class SerializableProc
   #
   def to_proc(binding = nil)
     if binding
-      eval(@code[:runnable], @binding.eval!(binding), @file, @line)
+      eval(@codes[:runnable], @binding.eval!(binding), @file, @line)
     else
-      @proc ||= eval(@code[:runnable], @binding.eval!, @file, @line)
+      @proc ||= eval(@codes[:runnable], @binding.eval!, @file, @line)
     end
   end
 
@@ -159,7 +156,7 @@ class SerializableProc
   # * global variable -> replaced '$ with 'gvar_'
   #
   def to_s(debug = false)
-    @code[debug ? :runnable : :extracted]
+    @codes[debug ? :runnable : :extracted]
   end
 
   ##
@@ -169,7 +166,7 @@ class SerializableProc
   #   SerializableProc.new { [x, @x, @@x, $x].join(', ') }.to_sexp
   #
   def to_sexp(debug = false)
-    @sexp[debug ? :runnable : :extracted]
+    @sexps[debug ? :runnable : :extracted]
   end
 
   ##

data/serializable_proc.gemspec

@@ -5,14 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = %q{serializable_proc}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["NgTzeYang"]
-  s.date = %q{2010-08-18}
+  s.date = %q{2010-09-15}
   s.description = %q{
-      Give & take, serializing a ruby proc is possible, though not a perfect one.
-      Requires either ParseTree (faster) or RubyParser (& Ruby2Ruby).
+      Give & take, serializing a ruby proc is possible, though not a perfect one (yet).
     }
   s.email = %q{ngty77@gmail.com}
   s.extra_rdoc_files = [
@@ -32,9 +31,6 @@ Gem::Specification.new do |s|
      "lib/serializable_proc/fixes.rb",
      "lib/serializable_proc/isolatable.rb",
      "lib/serializable_proc/marshalable.rb",
-     "lib/serializable_proc/parsers.rb",
-     "lib/serializable_proc/parsers/dynamic.rb",
-     "lib/serializable_proc/parsers/static.rb",
      "serializable_proc.gemspec",
      "spec/bounded_vars/class_vars_spec.rb",
      "spec/bounded_vars/class_vars_within_block_scope_spec.rb",
@@ -45,22 +41,8 @@ Gem::Specification.new do |s|
      "spec/bounded_vars/instance_vars_within_block_scope_spec.rb",
      "spec/bounded_vars/local_vars_spec.rb",
      "spec/bounded_vars/local_vars_within_block_scope_spec.rb",
-     "spec/code_block/errors_spec.rb",
      "spec/code_block/magic_vars_spec.rb",
-     "spec/code_block/multiple_arities_spec.rb",
-     "spec/code_block/optional_arity_spec.rb",
      "spec/code_block/renaming_vars_spec.rb",
-     "spec/code_block/single_arity_spec.rb",
-     "spec/code_block/zero_arity_spec.rb",
-     "spec/extending/new_matcher_w_multiple_arities_spec.rb",
-     "spec/extending/new_matcher_w_optional_arity_spec.rb",
-     "spec/extending/new_matcher_w_single_arity_spec.rb",
-     "spec/extending/new_matcher_w_zero_arity_spec.rb",
-     "spec/extending/spec_helper.rb",
-     "spec/extending/subclassing_w_multiple_arities_spec.rb",
-     "spec/extending/subclassing_w_optional_arity_spec.rb",
-     "spec/extending/subclassing_w_single_arity_spec.rb",
-     "spec/extending/subclassing_w_zero_arity_spec.rb",
      "spec/proc_like/extras_spec.rb",
      "spec/proc_like/invoking_with_args_spec.rb",
      "spec/proc_like/invoking_with_class_vars_spec.rb",
@@ -72,21 +54,6 @@ Gem::Specification.new do |s|
      "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/ngty/serializable_proc}
-  s.post_install_message = %q{
- /////////////////////////////////////////////////////////////////////////////////
-
-  ** SerializableProc **
-
-  You are installing SerializableProc on a ruby platform & version that supports
-  ParseTree. With ParseTree, u can enjoy better performance of SerializableProc,
-  as well as other dynamic code analysis goodness, as compared to the default
-  implementation using RubyParser's less flexible static code analysis.
-
-  Anyway, u have been informed, SerializableProc will fallback on its default
-  implementation using RubyParser.
-
- /////////////////////////////////////////////////////////////////////////////////
-      }
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
@@ -101,21 +68,7 @@ Gem::Specification.new do |s|
      "spec/proc_like/invoking_with_global_vars_spec.rb",
      "spec/proc_like/marshalling_spec.rb",
      "spec/code_block/magic_vars_spec.rb",
-     "spec/code_block/multiple_arities_spec.rb",
-     "spec/code_block/zero_arity_spec.rb",
-     "spec/code_block/errors_spec.rb",
      "spec/code_block/renaming_vars_spec.rb",
-     "spec/code_block/single_arity_spec.rb",
-     "spec/code_block/optional_arity_spec.rb",
-     "spec/extending/subclassing_w_optional_arity_spec.rb",
-     "spec/extending/subclassing_w_single_arity_spec.rb",
-     "spec/extending/new_matcher_w_multiple_arities_spec.rb",
-     "spec/extending/subclassing_w_zero_arity_spec.rb",
-     "spec/extending/new_matcher_w_single_arity_spec.rb",
-     "spec/extending/subclassing_w_multiple_arities_spec.rb",
-     "spec/extending/new_matcher_w_optional_arity_spec.rb",
-     "spec/extending/new_matcher_w_zero_arity_spec.rb",
-     "spec/extending/spec_helper.rb",
      "spec/bounded_vars/global_vars_within_block_scope_spec.rb",
      "spec/bounded_vars/instance_vars_within_block_scope_spec.rb",
      "spec/bounded_vars/errors_spec.rb",
@@ -133,14 +86,20 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ruby2ruby>, [">= 1.2.4"])
+      s.add_runtime_dependency(%q<sourcify>, [">= 0.2.2.1"])
+      s.add_runtime_dependency(%q<ruby2ruby>, [">= 1.2.5"])
+      s.add_runtime_dependency(%q<sexp_processor>, [">= 3.0.5"])
       s.add_development_dependency(%q<bacon>, [">= 0"])
     else
-      s.add_dependency(%q<ruby2ruby>, [">= 1.2.4"])
+      s.add_dependency(%q<sourcify>, [">= 0.2.2.1"])
+      s.add_dependency(%q<ruby2ruby>, [">= 1.2.5"])
+      s.add_dependency(%q<sexp_processor>, [">= 3.0.5"])
       s.add_dependency(%q<bacon>, [">= 0"])
     end
   else
-    s.add_dependency(%q<ruby2ruby>, [">= 1.2.4"])
+    s.add_dependency(%q<sourcify>, [">= 0.2.2.1"])
+    s.add_dependency(%q<ruby2ruby>, [">= 1.2.5"])
+    s.add_dependency(%q<sexp_processor>, [">= 3.0.5"])
     s.add_dependency(%q<bacon>, [">= 0"])
   end
 end

data/spec/bounded_vars/errors_spec.rb

@@ -6,22 +6,30 @@ describe 'SerializableProc::CannotSerializeVariableError' do
 
   should "raise if local variable cannot be marshalled" do
     f = Tempfile.new('fake')
-    lambda { SerializableProc.new{ f } }.should.be raising_cannot_serialize_variable_error('f')
+    lambda {
+      SerializableProc.new{ f }
+    }.should.be raising_cannot_serialize_variable_error('f')
   end
 
   should "raise if class variable cannot be marshalled" do
     @@f = Tempfile.new('fake')
-    lambda { SerializableProc.new{ @@f } }.should.be raising_cannot_serialize_variable_error('@@f')
+    lambda {
+      SerializableProc.new{ @@f }
+    }.should.be raising_cannot_serialize_variable_error('@@f')
   end
 
   should "raise if instance variable cannot be marshalled" do
     @f = Tempfile.new('fake')
-    lambda { SerializableProc.new{ @f } }.should.be raising_cannot_serialize_variable_error('@f')
+    lambda {
+      SerializableProc.new{ @f }
+    }.should.be raising_cannot_serialize_variable_error('@f')
   end
 
   should "raise if global variable cannot be marshalled" do
     $f = Tempfile.new('fake')
-    lambda { SerializableProc.new{ $f } }.should.be raising_cannot_serialize_variable_error('$f')
+    lambda {
+      SerializableProc.new{ $f }
+    }.should.be raising_cannot_serialize_variable_error('$f')
   end
 
 end

data/spec/bounded_vars/local_vars_within_block_scope_spec.rb

@@ -4,35 +4,35 @@ describe 'Extracting local vars within block scope' do
 
   extend SerializableProc::Spec::Helpers
 
-  should "not handle w @@_mingle_vars unspecified" do
+  should "not handle w @@_not_isolated_vars unspecified" do
     x = 'ox'
     should_have_empty_binding \
       SerializableProc.new { def test ; x = 'lx' ; end }
   end
 
-  should "not handle if @@_mingle_vars includes :local" do
+  should "not handle if @@_not_isolated_vars includes :local" do
     x = 'ox'
     should_have_empty_binding \
       SerializableProc.new {
-        @@_mingle_vars = :local
+        @@_not_isolated_vars = :local
         def test ; x = 'lx' ; end
       }
   end
 
-  should "not handle if @@_mingle_vars includes :all" do
+  should "not handle if @@_not_isolated_vars includes :all" do
     x = 'ox'
     should_have_empty_binding \
       SerializableProc.new {
-        @@_mingle_vars = :all
+        @@_not_isolated_vars = :all
         def test ; x = 'lx' ; end
       }
   end
 
-  should "not handle if @@_mingle_vars excludes :local" do
+  should "not handle if @@_not_isolated_vars excludes :local" do
     x = 'ox'
     should_have_empty_binding \
       SerializableProc.new {
-        @@_mingle_vars = nil
+        @@_not_isolated_vars = nil
         def test ; x = 'lx' ; end
       }
   end

data/spec/code_block/magic_vars_spec.rb

@@ -11,7 +11,7 @@ describe 'Handling magic vars' do
 
   should 'convert __LINE__' do
     SerializableProc.new { __LINE__ }.should.be \
-      having_runnable_code_as('proc { %s }' % __LINE__.pred)
+      having_runnable_code_as('proc { %s }' % (__LINE__ - 1))
   end
 
 end