source_proc 0.1

data/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2007 Samuel Lebeau
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

data/lib/source_proc.rb

@@ -0,0 +1,131 @@
+require 'rubygems'
+require 'forwardable'
+require 'binding_of_caller'
+
+# SourceProc objects are objects acting like Proc ones that can return
+# back their own source code.
+# They have to be created with a source string instead of a block, then
+# all proc method calls are delegated to an internal Proc object created
+# by evaluating this string.
+#
+# == Creation
+#
+# SourceProc objects can be created 2 ways:
+#   add = SourceProc.new('|a, b| a + b')
+# or:
+#   add = slambda '|a, b| a + b'
+# 
+# The first form creates its internal proc with <tt>Proc.new</tt>,
+# the second one with <tt>lambda,</tt> so Ruby semantics are preserved
+# and differences between procs and lambdas are kept.
+#
+# == Usage
+#
+#   add.call(3, 4)  # => 7
+#   add.arity       # => 2
+#   add.source      # => '|a, b| a + b'
+#
+# Be careful, SourceProc isn't a subclass of Proc, so
+#   add.is_a?(Proc) # => false
+#
+# Better way is to test if we can invoke 'call' on it
+#   add.respond_to(:call) # => true
+#
+# == Bindings
+#
+# When created inside a method, SourceProc objects will be given the current binding.
+# For instance:
+#
+#   str = 'Hello'
+#
+#   def foo
+#     slambda '|arg| str + arg'
+#   end
+#
+#   foo.call(' world !')      # => 'Hello world !'
+#   eval('str', foo.binding)  # => 'Hello'
+#
+# Due to the implementation of Binding.of_caller, the current binding will not be
+# given if SourceProc objects are created outside a method.
+# You can however pass a Binding object as second argument which will be used instead.
+#
+# Example:
+#
+#   str = 'Hello'
+#
+#   my_proc = slambda '|arg| str + arg'
+#   my_proc.call(' world !')  # => Error
+#
+#   # will give what is expected
+#   my_proc = slambda '|arg| str + arg', binding
+#   my_proc.call(' world !')  # => 'Hello world !'
+#
+# == Marshalling
+#
+# You can marshall SourceProc objects and restore them back,
+# except all bindings will be lost as Binding objects cannot be marshalled.
+# This could however be usefull if you restore them in the same context
+# you marshalled them.
+
+class SourceProc
+  extend Forwardable
+  
+  def SourceProc.new(source, binding = nil, is_lambda = false)
+    return super if binding
+    Binding.of_caller { |binding| super(source, binding, is_lambda) }
+  end
+  
+  def SourceProc._load(string)
+    # obviously loosing the original binding
+    eval(string)
+  end
+  
+  def initialize(source, binding, is_lambda)
+    @source, @is_lambda = source.freeze, is_lambda.freeze
+    @proc = eval(expression, binding)
+  end
+  
+  def_delegators :@proc, :to_proc, :arity, :binding, :call, :[], :==
+  
+  attr_reader :source
+  
+  def lambda?
+    @is_lambda
+  end
+  
+  def proc?
+    !@is_lambda
+  end
+
+  def dup
+    self.class.new(@source, @proc.binding, @is_lambda)
+  end
+  
+  def to_s(*args)
+    (@is_lambda ? 'slambda(' : 'SourceProc.new(') << source.inspect << ')'
+  end
+  alias _dump to_s
+
+  private
+    def method_missing?(meth_id, *args, &block)
+      @proc.respond_to?(meth_id) ? @proc.send(meth_id, *args, &block) : super
+    end
+
+    def expression
+      (@is_lambda ? 'lambda ' : 'Proc.new ') << source_with_braces
+    end
+
+    def source_with_braces
+      @source.index("\n") ? "do #@source\nend" : "{ #@source }"
+    end
+end
+
+module Kernel
+  # convenient SourceProc creator for lambdas
+  def slambda(source, binding = nil)
+    return SourceProc.new(source, binding, true) if binding
+    Binding.of_caller { |binding| SourceProc.new(source, binding, true) }
+  end
+ # deprecated
+  alias sproc slambda
+end

data/test/source_proc_test.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'source_proc'
+
+class SourceProcTest < Test::Unit::TestCase
+  def max_source
+    'a > b ? a : b'
+  end
+  
+  def test_creation
+    src = "|a, b| #{max_source}"
+    max = SourceProc.new(src)
+    max2 = slambda(src)
+    assert_equal(src, max.source)
+    assert_equal(src, max2.source)
+    assert(max2.lambda?)
+    assert_equal(4, max.call(3, 4))
+    assert_equal(4, max2.call(3, 4))
+    assert_nothing_raised(ArgumentError) { assert_equal(4, max.call(3, 4, 5)) }
+    assert_raise(ArgumentError) { max2.call(3, 4, 5) }
+  end
+  
+  def remote_call(proc)
+    proc.call
+  end
+
+  def test_bindings
+    a, b = 128, 5
+    max = slambda(max_source)
+    assert_equal(128, max.call)
+    assert_equal(128, remote_call(max))
+    array = []
+    push = slambda 'array.push(1664)'
+    push.call
+    assert_equal(1, array.size)
+    eval('array.push(0 + 0)', push.binding)
+    assert_equal(2, array.size)
+  end
+
+  def test_marshalling
+    f = slambda('|x, y| x + y')
+    g = SourceProc.new('ENV')
+    assert_nothing_raised do
+      f = Marshal.load(Marshal.dump(f))
+      g = Marshal.load(Marshal.dump(g))
+    end
+    assert_kind_of(SourceProc, f)
+    assert(f.lambda?)
+    assert(!g.lambda?)
+    assert_equal('|x, y| x + y', f.source)
+    assert_equal(2020, f.call(2012, 8))
+    assert_equal(ENV, g.call)
+  end
+  
+  def test_dup
+    f, g = slambda('|x| x'), nil
+    assert_nothing_raised(Exception) { g = f.dup }
+    assert_equal(f.source, g.source)
+    assert_equal(g.call(true))
+  end
+
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: source_proc
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2007-08-08 00:00:00 +02:00
+summary: Proc objects that can give back their source code.
+require_paths: 
+- lib
+email: sam@gotfresh.info
+homepage: http://i.gotfresh.info
+rubyforge_project: 
+description: SourceProc objects are created with a source string and binding and delegate calls  to the corresponding Proc object letting you access to the original source code.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Samuel Lebeau
+files: 
+- LICENSE
+- lib/source_proc.rb
+- test/source_proc_test.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: call_stack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0.0
+    version: