acts_as_runnable_code 1.0.0

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2007-10-22
+
+* 1 major enhancement
+  * Birthday!
+

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,69 @@
+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:
+
+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,18 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/acts_as_runnable_code.rb'
+
+Hoe.new('acts_as_runnable_code', ActsAsRunnableCode::VERSION) do |p|
+  p.rubyforge_name = 'acts_as_runnable_code'
+  p.author = 'David Stevenson'
+  p.email = 'ds@elctech.com'
+  p.summary = 'Mark a class as containing a method which returns sandbox runnable code.  Helps by building the sandbox and setting up the eval for you.'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.rubyforge_name = "runnable-code"
+end
+
+# vim: syntax=Ruby

data/lib/acts_as_runnable_code.rb

@@ -0,0 +1,76 @@
+# ActsAsRunnableCode
+require "rubygems"
+require "acts_as_wrapped_class"
+
+module ActsAsRunnableCode
+  VERSION="1.0.0"
+  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|
+        s.ref eval("#{c}Wrapper")
+      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    
+  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,79 @@
+require "sandbox"
+require 'test/unit'
+require File.dirname(__FILE__) + "/../lib/acts_as_runnable_code"
+
+class SampleClass
+  acts_as_runnable_code 
+  
+  def code
+    "'hello world'"
+  end
+end
+
+class OtherClass
+  acts_as_runnable_code :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
+    w = WrappedClass.new(5.5)
+    assert_equal "hello world", SampleClass.new.run_code
+    assert_equal 5.5, OtherClass.new.run_code(w)
+    
+    oc = OtherClass.new
+    oc.code = "other"
+    assert_equal WrappedClass, oc.run_code(w).class
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: acts_as_runnable_code
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-10-22 00:00:00 -07:00
+summary: Mark a class as containing a method which returns sandbox runnable code.  Helps by building the sandbox and setting up the eval for you.
+require_paths: 
+- lib
+email: ds@elctech.com
+homepage: "    by David Stevenson"
+rubyforge_project: runnable-code
+description: "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:  class Algorithm < ActiveRecord::Base # \"code\" is a database attribute in this case, containing user's code acts_as_runnable_code :classes => [\"Board\"] end"
+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: 
+- David Stevenson
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/acts_as_runnable_code.rb
+- test/test_acts_as_runnable_code.rb
+test_files: 
+- test/test_acts_as_runnable_code.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: