dsboulder-acts_as_runnable_code 1.0.3

data/History.txt

@@ -0,0 +1,6 @@
+== 1.0.1 / 2007-10-22
+* added gem dependency to acts_as_wrapped_class 
+
+== 1.0.0 / 2007-10-22
+
+* first relase

data/Manifest.txt

@@ -0,0 +1,6 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/acts_as_runnable_code.rb
+test/test_acts_as_runnable_code.rb

data/README.txt

@@ -0,0 +1,72 @@
+ActsAsRunnableCode
+    by David Stevenson
+    http://elctech.com/blog
+
+== DESCRIPTION:
+  
+ActsAsRunnable attempts to make the Freaky Freaky Sandbox easier to use.  It assumes that you have a class that has instances that store user uploaded code in them.  It also assumes that you want use your classes in the sandbox with reduced "safe" functionality provided by acts_as_wrapped_class.  Finally, it assumes that you want to evaluate an instance of user uploaded code within the context of some instance of a wrapped class.
+
+See the example app using this gem: http://tictactoe.mapleton.net
+
+== FEATURES/PROBLEMS:
+  
+* Run user uploaded code in the sandbox
+* Automatic use of wrapper classes inside the sandbox, and unwrapping return results
+
+== SYNOPSIS:
+
+	require "sandbox"
+	require "acts_as_runnable_code"
+
+	class Algorithm < ActiveRecord::Base
+	  # "code" is a database attribute in this case, containing user's code
+	  acts_as_runnable_code :classes => ["Board"]
+	end
+
+	class Board < ActiveRecord::Base
+	  belongs_to :algorithm
+	  acts_as_wrapped_class, :methods => [:moves, :make_move!, :turn, :log_info, :log_debug]
+	  def moves; end
+	  def make_move!(x,y); end;
+	  ...
+	end
+
+	# Runs a user uploaded alogrithm in the context of a board
+	board = Board.find(id)
+	board.algorithm.run_code(board, :timeout => 0.5)
+
+== REQUIREMENTS:
+
+* acts_as_wrapped_class (gem)
+* sandbox (gem)
+
+== INSTALL:
+
+* sudo gem install acts_as_wrapped_class
+* download and install sandbox: http://code.whytheluckystiff.net/sandbox/
+* sudo gem install acts_as_runnable_code
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 David Stevenson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,13 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "acts_as_runnable_code"
+    gemspec.summary = "Sandbox support gem to help define user-provided algorithms"
+    gemspec.email = "david@flouri.sh"
+    gemspec.homepage = "http://github.com/dsboulder/acts_as_runnable_code"
+    gemspec.description = "TODO"
+    gemspec.authors = ["David Stevenson"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 1
+:minor: 0
+:patch: 3

data/lib/acts_as_runnable_code.rb

@@ -0,0 +1,103 @@
+# ActsAsRunnableCode
+require "rubygems"
+require "acts_as_wrapped_class"
+
+module ActsAsRunnableCode
+  VERSION="1.0.2"
+  module InstanceMethods
+    # Run the user's code in the context of a toplevel_object
+    # The toplevel_object will be automatically wrapped and copied into the sandbox
+    def run_code(toplevel_object = nil, options = {})
+      options[:timeout] ||= self.class.runnable_code_options[:timeout] 
+      s = sandbox
+      if toplevel_object
+        s.set(:toplevel, ActsAsWrappedClass::WrapperFinder.find_wrapper_for(toplevel_object))
+        s.set(:code, self.send(self.class.source_code_field))
+        result = s.eval("eval(code, toplevel.send(:binding))", options)
+      else
+        s.set(:code, self.send(self.class.source_code_field))        
+        result = s.eval("eval(code)", options)
+      end
+      result.class.respond_to?(:wrapper_class?) && result.class.wrapper_class? ? result._wrapped_object : result
+    end
+    
+    # Get the sandbox used to eval user code for this class
+    # Makes sandbox references to the wrapper classes
+    def sandbox
+      return self.class.instance_variable_get("@sandbox") if self.class.instance_variables.include?("@sandbox")
+      
+      if self.class.runnable_code_options[:unsafe_sandbox]
+        s = Sandbox.new
+      else
+        s = Sandbox.safe
+      end
+      
+      classes = self.class.runnable_code_options[:classes] || ActsAsWrappedClass::WRAPPED_CLASSES
+      
+      classes.each do |c|
+        name = "#{c}Wrapper"
+        s.ref eval(name)
+      end
+      
+      self.class.instance_variable_set("@sandbox", s) if self.class.runnable_code_options[:singleton_sandbox]
+      s
+    end
+  end
+  
+  module ClassMethods
+    attr :runnable_code_options, true
+    
+    def source_code_field
+      (@runnable_code_options[:code_field] || "code").to_sym
+    end
+    
+    def runnable_code?
+      true
+    end
+
+    # a list of runnable classes in the format ["SomeClassWrapper", "OtherClassWraper"]
+    def runnable_classes
+      (runnable_code_options[:classes] || ActsAsWrappedClass::WRAPPED_CLASSES).collect { |c| "#{c}Wrapper" }
+    end
+        
+    # a list of runnable methods in the format {"SomeClassWrapper" => ["method_a", "method_b"], "OtherClassWraper" => ["method_c", "method_d"]]
+    def runnable_methods
+      meths = {}
+      runnable_classes.each { |c|
+        klass = eval("::#{c}")
+        meths[c.to_s] ||= []
+        meths[c.to_s] += klass.allowed_methods if klass.respond_to?(:allowed_methods)
+      }
+      meths
+    end
+    
+    # same as runnable methods but excludes all the methods of +Object
+    def runnable_methods_no_object
+      newv = {}
+      runnable_methods.each do |k,v|
+        newv[k] = v - Object.public_instance_methods
+      end
+      newv
+    end
+  end
+  
+  # Mark this class as containing a method which returns user generated code.
+  # Options
+  # * options[:classes] - contains a list of classes (unwrapped names) you want accessible in the sandbox. Default: all classes loaded and marked with acts_as_wrapped_class
+  # * options[:singleton_sandbox] - only create 1 sandbox, which is always used whenever code is evaled (faster), rather than a new sandbox each time.  Default: false
+  # * options[:unsafe_sandbox] - create sandbox using Sandbox.new rather than Sandbox.safe.  Default: false
+  # * options[:timeout] - timeout in seconds before aborting user code.  Default: none
+  # * options[:code_field] - the name of the method to call to get the user code for running.  Default: :code
+  def acts_as_runnable_code(options = {})
+    self.send(:include, InstanceMethods)
+    self.send(:extend,ClassMethods)
+    
+    self.runnable_code_options = options
+  end
+  
+  def runnable_code?
+    false
+  end
+end
+
+Object.send(:include, ActsAsRunnableCode)

data/test/test_acts_as_runnable_code.rb

@@ -0,0 +1,115 @@
+require "sandbox"
+require 'test/unit'
+require File.dirname(__FILE__) + "/../lib/acts_as_runnable_code"
+
+class SampleClass
+  acts_as_runnable_code 
+  
+  attr_writer :code
+  
+  def code
+    @code || "'hello world'"
+  end
+  
+end
+
+class WrappedClass2
+  acts_as_wrapped_class :methods => [:safeone]
+  
+  def safeone
+    777
+  end
+  
+  def unsafeone
+    666
+  end  
+end
+
+class OtherClass
+  acts_as_runnable_code :classes => ["WrappedClass2"], :code_field => :data2, :unsafe_sandbox => true, :singleton_sandbox => true
+  
+  attr :code, true
+  
+  def data2
+    @code || "value"
+  end
+end
+
+class WrappedClass
+  acts_as_wrapped_class
+  
+  attr_reader :value  
+  
+  def initialize(value)
+    @value = value
+  end
+  
+  def other
+    WrappedClass.new(rand)
+  end
+end
+
+class ActsAsRunnableCodeTest < Test::Unit::TestCase
+  def test_source_code_field
+    assert_equal :code, SampleClass.source_code_field
+    assert_equal :data2, OtherClass.source_code_field
+  end
+  
+  def test_has_run_code
+    assert SampleClass.new.respond_to?(:run_code)
+    assert OtherClass.new.respond_to?(:run_code)
+  end
+  
+  def test_has_sandbox
+    assert SampleClass.new.respond_to?(:sandbox)
+    assert OtherClass.new.respond_to?(:sandbox)
+  end
+  
+  def test_sandbox
+    s = SampleClass.new.sandbox
+    assert s.is_a?(Sandbox::Safe)
+    
+    s = OtherClass.new.sandbox
+    assert s.is_a?(Sandbox::Full)
+  end
+  
+  def test_singleton_sandbox
+    s1 = OtherClass.new.sandbox
+    s2 = OtherClass.new.sandbox
+    assert s1 == s2
+    s1 = SampleClass.new.sandbox
+    s2 = SampleClass.new.sandbox
+    assert s1 != s2
+  end
+  
+  def test_run_code
+    assert_equal "hello world", SampleClass.new.run_code
+
+    w = WrappedClass.new(5.5)    
+    sc = SampleClass.new
+    sc.code = "value"
+    assert_equal 5.5, sc.run_code(w)
+    
+    sc = SampleClass.new
+    sc.code = "other"
+    assert_equal WrappedClass, sc.run_code(w).class
+  
+    w = WrappedClass2.new
+    oc = OtherClass.new
+    oc.code = "safeone"
+    assert_equal 777, oc.run_code(w)
+  end
+  
+  def test_arunnable_classes
+    assert_equal 2, SampleClass.runnable_classes.length
+    assert_equal ["WrappedClass2Wrapper"], OtherClass.runnable_classes
+
+    assert_equal OtherClass.runnable_methods, {"WrappedClass2Wrapper" => ["safeone"]}
+    assert_contents_same ["other", "value", "safeone"], SampleClass.runnable_methods_no_object.values.flatten.uniq
+  end
+  
+  def assert_contents_same(array1, array2)
+    assert_equal array1.length, array2.length, "#{array1.inspect} != #{array2.inspect}"
+    array1.each { |a| assert array2.include?(a), "#{array2.inspect} does not contain #{a.inspect}" }
+  end  
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: dsboulder-acts_as_runnable_code
+version: !ruby/object:Gem::Version 
+  version: 1.0.3
+platform: ruby
+authors: 
+- David Stevenson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: TODO
+email: david@flouri.sh
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- VERSION.yml
+- lib/acts_as_runnable_code.rb
+- test/test_acts_as_runnable_code.rb
+has_rdoc: true
+homepage: http://github.com/dsboulder/acts_as_runnable_code
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Sandbox support gem to help define user-provided algorithms
+test_files: 
+- test/test_acts_as_runnable_code.rb