jruby_sandbox 0.2.2-java → 0.2.3-java

data/spec/sandbox_spec.rb

@@ -1,6 +1,6 @@
-require 'rspec'
-require 'sandbox'
-require 'timeout'
+require "rspec"
+require "sandbox"
+require "timeout"
 
 describe Sandbox do
   after(:each) do
@@ -19,42 +19,42 @@ describe Sandbox do
 
     it { should be_an_instance_of(Sandbox::Safe) }
 
-    it 'should not lock down until calling activate!' do
-      subject.eval('`echo hello`').should == "hello\n"
+    it "should not lock down until calling activate!" do
+      subject.eval(%|`echo hello`|).should == "hello\n"
 
       subject.activate!
 
       expect {
-        subject.eval('`echo hello`')
+        subject.eval(%|`echo hello`|)
       }.to raise_error(Sandbox::SandboxException)
     end
-    
+
     it "should activate FakeFS inside the sandbox (and not allow it to be deactivated)" do
-      subject.eval('File').should == ::File
-      
+      subject.eval(%|File|).should == ::File
+
       subject.activate!
-      
-      foo = File.join(File.dirname(__FILE__), 'support', 'foo.txt')
+
+      foo = File.join(File.dirname(__FILE__), "support", "foo.txt")
 
       expect {
-        subject.eval(%{File.read('#{foo}')})
+        subject.eval(%{File.read("#{foo}")})
       }.to raise_error(Sandbox::SandboxException, /Errno::ENOENT: No such file or directory/)
-      
-      subject.eval('File').should == FakeFS::File
-      subject.eval('Dir').should == FakeFS::Dir
-      subject.eval('FileUtils').should == FakeFS::FileUtils
-      subject.eval('FileTest').should == FakeFS::FileTest
-      
+
+      subject.eval(%|File|).should == FakeFS::File
+      subject.eval(%|Dir|).should == FakeFS::Dir
+      subject.eval(%|FileUtils|).should == FakeFS::FileUtils
+      subject.eval(%|FileTest|).should == FakeFS::FileTest
+
       subject.eval(%{FakeFS.deactivate!})
-      
+
       expect {
-        subject.eval(%{File.read('#{foo}')})
+        subject.eval(%{File.read("#{foo}")})
       }.to raise_error(Sandbox::SandboxException, /Errno::ENOENT: No such file or directory/)
-      
-      subject.eval(%{File.open('/bar.txt', 'w') {|file| file << "bar" }})
-      
+
+      subject.eval(%{File.open("/bar.txt", "w") {|file| file << "bar" }})
+
       expect {
-        subject.eval(%{FileUtils.cp('/bar.txt', '/baz.txt')})
+        subject.eval(%{FileUtils.cp("/bar.txt", "/baz.txt")})
       }.to_not raise_error(Sandbox::SandboxException, /NoMethodError/)
     end
   end
@@ -68,14 +68,14 @@ describe Sandbox do
       pending do
         sandbox = Sandbox.new
         sandbox.ref(Sandbox)
-        sandbox.eval('Sandbox.current').should == sandbox
+        sandbox.eval(%|Sandbox.current|).should == sandbox
       end
     end
   end
-  
+
   describe "#eval with timeout" do
     subject { Sandbox.safe }
-    
+
     context "before it's been activated" do
       it "should protect against long running code" do
         long_code = <<-RUBY
@@ -86,21 +86,21 @@ describe Sandbox do
           subject.eval(long_code, timeout: 1)
         }.to raise_error(Sandbox::TimeoutError)
       end
-      
+
       it "should not raise a timeout error if the code runs in under the passed in time" do
         short_code = <<-RUBY
           1+1
         RUBY
-        
+
         expect {
           subject.eval(short_code, timeout: 1)
         }.to_not raise_error(Sandbox::TimeoutError)
       end
     end
-    
+
     context "after it's been activated" do
       before(:each) { subject.activate! }
-      
+
       it "should protect against long running code" do
         long_code = <<-RUBY
           while true; end
@@ -110,12 +110,12 @@ describe Sandbox do
           subject.eval(long_code, timeout: 1)
         }.to raise_error(Sandbox::TimeoutError)
       end
-      
+
       it "should persist state between evaluations" do
-        subject.eval('o = Object.new', timeout: 1)
-        
+        subject.eval(%|o = Object.new|, timeout: 1)
+
         expect {
-          subject.eval('o', timeout: 1)
+          subject.eval(%|o|, timeout: 1)
         }.to_not raise_error(Sandbox::SandboxException)
       end
     end
@@ -127,50 +127,50 @@ describe Sandbox do
     it "should allow a range of common operations" do
       operations = <<-OPS
         1 + 1
-        'foo'.chomp
-        'foo'
+        "foo".chomp
+        "foo"
       OPS
-      subject.eval(operations).should == 'foo'
+      subject.eval(operations).should == "foo"
     end
-    
+
     it "should have an empty ENV" do
       pending do
-        subject.eval(%{ENV.to_a}).should be_empty 
+        subject.eval(%{ENV.to_a}).should be_empty
       end
     end
 
     it "should persist state between evaluations" do
-      subject.eval('o = Object.new')
-      subject.eval('o').should_not be_nil
+      subject.eval(%|o = Object.new|)
+      subject.eval(%|o|).should_not be_nil
     end
 
     it "should be able to define a new class in the sandbox" do
-      result = subject.eval('Foo = Struct.new(:foo); struct = Foo.new("baz"); struct.foo')
-      result.should == 'baz'
+      result = subject.eval(%|Foo = Struct.new(:foo); struct = Foo.new("baz"); struct.foo|)
+      result.should == "baz"
     end
 
     it "should be able to use a class across invocations" do
       # Return nil, because the environment doesn't know "Foo"
-      subject.eval('Foo = Struct.new(:foo); nil')
-      subject.eval('struct = Foo.new("baz"); nil')
-      subject.eval('struct.foo').should == 'baz'
+      subject.eval(%|Foo = Struct.new(:foo); nil|)
+      subject.eval(%|struct = Foo.new("baz"); nil|)
+      subject.eval(%|struct.foo|).should == "baz"
     end
 
     describe "communication between sandbox and environment" do
       it "should be possible to pass data from the box to the environment" do
         Foo = Struct.new(:foo)
         subject.ref(Foo)
-        struct = subject.eval('struct = Foo.new')
-        subject.eval('struct.foo = "baz"')
-        struct.foo.should == 'baz'
+        struct = subject.eval(%|struct = Foo.new|)
+        subject.eval(%|struct.foo = "baz"|)
+        struct.foo.should == "baz"
       end
 
       it "should be possible to pass data from the environment to the box" do
         Foo = Struct.new(:foo)
         subject.ref(Foo)
-        struct = subject.eval('struct = Foo.new')
-        struct.foo = 'baz'
-        subject.eval('struct.foo').should == 'baz'
+        struct = subject.eval(%|struct = Foo.new|)
+        struct.foo = "baz"
+        subject.eval(%|struct.foo|).should == "baz"
       end
 
       it "should be able to pass large object data from the box to the environment" do
@@ -181,49 +181,49 @@ describe Sandbox do
         }.to_not raise_error(Sandbox::SandboxException)
 
         expect {
-          subject.eval %{'RUBY'*100}
+          subject.eval %{"RUBY"*100}
         }.to_not raise_error(Sandbox::SandboxException)
       end
     end
   end
-  
+
   describe "#import" do
     subject { Sandbox.new }
-    
+
     it "should be able to call a referenced namespaced module method" do
       Foo = Class.new
       Foo::Bar = Module.new do
         def baz
-          'baz'
+          "baz"
         end
         module_function :baz
       end
 
       subject.import(Foo::Bar)
-      subject.eval('Foo::Bar.baz').should == 'baz'
+      subject.eval(%|Foo::Bar.baz|).should == "baz"
     end
 
     it "should be able to include a module from the environment" do
       Foo = Module.new do
         def baz
-          'baz'
+          "baz"
         end
       end
 
       subject.import(Foo)
-      subject.eval("class Bar; include Foo; end; nil")
-      subject.eval('Bar.new.baz').should == 'baz'
+      subject.eval(%|class Bar; include Foo; end; nil|)
+      subject.eval(%|Bar.new.baz|).should == "baz"
     end
-    
+
     it "should be able to copy instance methods from a module that uses module_function" do
-      Foo = Module.new do        
-        def baz; 'baz'; end
-        
+      Foo = Module.new do
+        def baz; "baz"; end
+
         module_function :baz
       end
-      
+
       subject.import Foo
-      subject.eval('Foo.baz').should == 'baz'
+      subject.eval(%|Foo.baz|).should == "baz"
     end
   end
 
@@ -233,28 +233,28 @@ describe Sandbox do
     it "should be possible to reference a class defined outside the box" do
       Foo = Class.new
       subject.ref(Foo)
-      subject.eval('Foo.new').should be_an_instance_of(Foo)
+      subject.eval(%|Foo.new|).should be_an_instance_of(Foo)
     end
 
     it "should be possible to change the class after the ref" do
       Foo = Class.new
       subject.ref(Foo)
-      def Foo.foo; 'baz'; end
-      subject.eval('Foo.foo').should == 'baz'
+      def Foo.foo; "baz"; end
+      subject.eval(%|Foo.foo|).should == "baz"
     end
 
     it "should be possible to dynamically add a class method after the ref" do
       Foo = Class.new
       subject.ref(Foo)
-      Foo.class_eval('def Foo.foo; "baz"; end')
-      subject.eval('Foo.foo').should == 'baz'
+      Foo.class_eval(%|def Foo.foo; "baz"; end|)
+      subject.eval(%|Foo.foo|).should == "baz"
     end
 
     it "should be possible to dynamically add a class method after the ref" do
       Foo = Class.new
       subject.ref(Foo)
-      Foo.instance_eval('def Foo.foo; "baz"; end')
-      subject.eval('Foo.foo').should == 'baz'
+      Foo.instance_eval(%|def Foo.foo; "baz"; end|)
+      subject.eval(%|Foo.foo|).should == "baz"
     end
 
     it "should be possible to call a method on the class that receives a block" do
@@ -264,7 +264,7 @@ describe Sandbox do
         end
       end
       subject.ref(Foo)
-      subject.eval(%{Foo.bar { "baz" }}).should == 'baz'
+      subject.eval(%|Foo.bar { "baz" }|).should == "baz"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jruby_sandbox
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: java
 authors:
 - Dray Lacy
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-11-30 00:00:00.000000000 Z
+date: 2014-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fakefs
@@ -91,9 +91,9 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .ruby-version
-- .rvmrc
+- .travis.yml
+- CHANGELOG.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -105,6 +105,7 @@ files:
 - jruby_sandbox.gemspec
 - lib/sandbox.rb
 - lib/sandbox/prelude.rb
+- lib/sandbox/safe.rb
 - lib/sandbox/version.rb
 - spec/exploits_spec.rb
 - spec/sandbox_spec.rb
@@ -137,3 +138,4 @@ test_files:
 - spec/exploits_spec.rb
 - spec/sandbox_spec.rb
 - spec/support/foo.txt
+has_rdoc:

data/.rvmrc

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-# This is an RVM Project .rvmrc file, used to automatically load the ruby
-# development environment upon cd'ing into the directory
-
-# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
-environment_id="jruby-1.6.3@jruby_sandbox"
-
-#
-# Uncomment following line if you want options to be set only for given project.
-#
-PROJECT_JRUBY_OPTS=( --1.9 )
-
-#
-# First we attempt to load the desired environment directly from the environment
-# file. This is very fast and efficient compared to running through the entire
-# CLI and selector. If you want feedback on which environment was used then
-# insert the word 'use' after --create as this triggers verbose mode.
-#
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
-  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
-then
-  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-
-  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
-  then
-    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
-  fi
-else
-  # If the environment file has not yet been created, use the RVM CLI to select.
-  if ! rvm --create  "$environment_id"
-  then
-    echo "Failed to create RVM environment '${environment_id}'."
-    exit 1
-  fi
-fi
-
-#
-# If you use an RVM gemset file to install a list of gems (*.gems), you can have
-# it be automatically loaded. Uncomment the following and adjust the filename if
-# necessary.
-#
-# filename=".gems"
-# if [[ -s "$filename" ]] ; then
-#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
-# fi
-

data/Gemfile.lock

@@ -1,40 +0,0 @@
-GIT
-  remote: git://github.com/codeschool/fakefs.git
-  revision: 6ae3212e3dab013b4b5e290d1aceba6466b30dec
-  ref: 6ae3212e3dab013b4b5e290d1aceba6466b30dec
-  specs:
-    fakefs (0.4.0)
-
-PATH
-  remote: .
-  specs:
-    jruby_sandbox (0.2.2-java)
-      fakefs
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.1.2)
-    rake (0.9.2)
-    rake-compiler (0.7.9)
-      rake
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
-    yard (0.7.2)
-
-PLATFORMS
-  java
-
-DEPENDENCIES
-  fakefs!
-  jruby_sandbox!
-  rake
-  rake-compiler
-  rspec
-  yard