rVM 0.0.14 → 0.0.17

data/lib/rvm/rails.rb

@@ -1,4 +1,28 @@
-require File.dirname(__FILE__) +'/acts_as_rvm_type.rb'
+=begin
+The MIT License
+
+Copyright (c) 2008 Heinz N. 'Licenser' Gies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Ruby Mush"), 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.
+=end
+
+require 'rvm/acts_as_rvm_type.rb'
 
 # Inlcude the RVM::ACtsAsRVMType into active record so functions like
 # +acts_as_rvm_type+ and comparable
@@ -6,60 +30,61 @@ ActiveRecord::Base.class_eval do
   include RVM::ActsAsRVMType
 end
 
-class ActionView::Base
-  
-  # This function allows to render code that gets compiled by rvm. The first
-  # parameter passed is the code to compile, a string most likely, the second
-  # is a hash that is passed to the render function, see the Rails API doc for
-  # details on what to put there.
-  #
-  # In addition to those rails specifc parameters rvm_render accepts 4 additioal
-  # parameters.They are the same as used in +rvm_execute+.
-  def rvm_reder code, options = {}
-    render options.merge({:text => rvm_execute(code, options)})
-  end
-
-
-  # The rvm_execute executes a string of code with a certein behavior and
-  # returns not the result but what was written in the special :render variable
-  # of the enviroment.
-  #
-  # The folowing options can be passed to it to influence it's behaviro.
-  #
-  # :language:: The language that should be used to compile the code, be adwised
-  #             that it is nessessary to load this prior to executing it.
-  #
-  # :enviroment:: This allows to pass a own enviroment, for example to publish
-  #               variables or to maintain state between executions.
-  #
-  # :object:: If this is set the code will be executed in the context of the
-  #           object passed, this using it's local variable storage and it's
-  #           functions. Be aware that when using :object and :enviroment
-  #           togehter, variables set in the code will NOT go in the enviroment
-  #           as they are local in the object.
-  #
-  # :timeout:: This is used to limit the execution time of the code, it can be
-  #            used to prevent runaway processes beeing executed. Very helpfull
-  #            when the code executed isn't 100% trunstworty.
-  def rvm_execute code, options = {}
-    options = {
-      :language => :ecma,
-      :enviroment => RVM::Interpreter.env
-    }.merge(options)
-    compiler = RVM::Languages[options[:language]].new
-    code = compiler.compile(code)
-    code = RVM::Interpreter::ObjectContext.new(RVM::Interpreter::Constant.new(options[:object]), code) if options[:object]
-    if options[:enviroment][:render].is_a? RVM::Classes::Error or options[:enviroment][:render].nil?
-      options[:enviroment][:render] = ""
+module ActionController #:nodoc:
+  class Base
+    # This function allows to render code that gets compiled by rvm. The first
+    # parameter passed is the code to compile, a string most likely, the second
+    # is a hash that is passed to the render function, see the Rails API doc for
+    # details on what to put there.
+    #
+    # In addition to those rails specifc parameters rvm_render accepts 4 additioal
+    # parameters.They are the same as used in +rvm_execute+.
+    def rvm_reder code, options = {}
+      render options.merge({:text => rvm_execute(code, options)})
     end
-    puts options[:enviroment][:render].inspect
-    if options[:timeout]
-      s = RVM::Safety.new :timeout => options[:timeout]
-      s.execute(code, options[:enviroment])
-    else
-      code.execute(options[:enviroment])
+    
+    
+    # The rvm_execute executes a string of code with a certein behavior and
+    # returns not the result but what was written in the special :render variable
+    # of the environment.
+    #
+    # The folowing options can be passed to it to influence it's behaviro.
+    #
+    # :language:: The language that should be used to compile the code, be adwised
+    #             that it is nessessary to load this prior to executing it.
+    #
+    # :environment:: This allows to pass a own environment, for example to publish
+    #               variables or to maintain state between executions.
+    #
+    # :object:: If this is set the code will be executed in the context of the
+    #           object passed, this using it's local variable storage and it's
+    #           functions. Be aware that when using :object and :environment
+    #           togehter, variables set in the code will NOT go in the environment
+    #           as they are local in the object.
+    #
+    # :timeout:: This is used to limit the execution time of the code, it can be
+    #            used to prevent runaway processes beeing executed. Very helpfull
+    #            when the code executed isn't 100% trunstworty.
+    def rvm_execute code, options = {}
+      options = {
+        :language => :ecma,
+        :environment => RVM::Interpreter.env
+      }.merge(options)
+      compiler = RVM::Languages[options[:language]].new
+      code = compiler.compile(code)
+      code = RVM::Interpreter::ObjectContext.new(RVM::Interpreter::Constant.new(options[:object]), code) if options[:object]
+      if options[:environment][:render].is_a? RVM::Classes::Error or options[:environment][:render].nil?
+        options[:environment][:render] = ""
+      end
+      puts options[:environment][:render].inspect
+      if options[:timeout]
+        s = RVM::Safety.new :timeout => options[:timeout]
+        s.execute(code, options[:environment])
+      else
+        code.execute(options[:environment])
+      end
+      options[:environment][:render].val
     end
-    options[:enviroment][:render].val
   end
 end
-require File.dirname(__FILE__) + '/functions/rails.rb'
+require 'rvm/functions/rails.rb'

data/spec/classes/atom/association_spec.rb

@@ -1,8 +1,8 @@
-require File.dirname(__FILE__) +'/../../../lib/rvm/classes'
-require File.dirname(__FILE__) +'/../../../lib/rvm/classes/association'
-require File.dirname(__FILE__) +'/../../../lib/rvm/functions/association/assoc_get'
-require File.dirname(__FILE__) +'/../../../lib/rvm/functions/association/assoc_set'
-require File.dirname(__FILE__) +'/../../../lib/rvm/functions/collection/size'
+require 'rvm/classes'
+require 'rvm/classes/association'
+require 'rvm/functions/association/assoc_get'
+require 'rvm/functions/association/assoc_set'
+require 'rvm/functions/collection/size'
 
 describe RVM::Classes::Association do
   
@@ -26,14 +26,14 @@ describe RVM::Classes::Association do
   end
   
   it "should publish a get method" do
-    @assoc.functions.should include('get')
+    @assoc.functions.keys.should include('get')
   end
   
   it "should publish a set method" do
-    @assoc.functions.should include('set')
+    @assoc.functions.keys.should include('set')
   end
   
   it "should publich a size method" do
-    @assoc.functions.should include('size')
+    @assoc.functions.keys.should include('size')
   end
 end

data/spec/classes/atom/block_spec.rb

@@ -1,6 +1,11 @@
-require File.dirname(__FILE__) +'/../../../lib/rvm/classes'
+require 'rvm/classes'
+require 'rvm/interpreter'
 describe RVM::Classes::Block do
   
+  before(:each) do
+    @env = RVM::Interpreter.env
+  end
+  
   it "should create with a value" do
     b = RVM::Classes::Block.new(nil)
   end
@@ -12,16 +17,14 @@ describe RVM::Classes::Block do
   
   it "should do nothign on execution" do
     code = mock('code mock')
-    env = mock('env mock')
     b = RVM::Classes::Block.new(code)
-    b.execute(env).should be_nil
+    b.execute(@env).should be_nil
   end
   
   it "should execute the given code" do
     code = mock('code mock')
-    env = mock('env mock')
     b = RVM::Classes::Block.new(code)
     code.should_receive(:execute).once.with(any_args).and_return(42)
-    b.call(env, []).should be(42)
+    b.call([], @env).should be(42)
   end
 end

data/spec/classes/atom/boolean_spec.rb

@@ -1,4 +1,4 @@
-require "lib/rvm/classes/boolean"
+require "rvm/classes/boolean"
 describe RVM::Classes::Boolean do
   
   

data/spec/classes/atom/error_spec.rb

@@ -1,4 +1,4 @@
-require "lib/rvm/classes/error"
+require "rvm/classes/error"
 describe RVM::Classes::Error do
   
   describe "(creation)" do

data/spec/classes/atom/list_spec.rb

@@ -1,4 +1,4 @@
-require "lib/rvm/classes/list"
+require "rvm/classes/list"
 describe RVM::Classes::List do
   
   describe "(creation)" do

data/spec/classes/atom/number_spec.rb

@@ -1,5 +1,5 @@
-require "lib/rvm/classes"
-require "lib/rvm/classes/number"
+require "rvm/classes"
+require "rvm/classes/number"
 
 describe RVM::Classes::Number do
   

data/spec/classes/atom/string_spec.rb

@@ -1,4 +1,4 @@
-require "lib/rvm/classes/string"
+require "rvm/classes/string"
 
 describe RVM::Classes::String do
   

data/spec/languages/ecma/ecma_spec.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) +'/../../../lib/rvm'
-require File.dirname(__FILE__) +'/../../../lib/rvm/languages'
-require File.dirname(__FILE__) +'/../../../lib/rvm/languages/ecma'
+require 'rvm'
+require 'rvm/languages'
+require 'rvm/languages/ecma'
 
 describe RVM::Languages::ECMA do
   def exec code
@@ -27,28 +27,28 @@ describe RVM::Languages::ECMA do
       end
       
       it "should handle newline replacements" do
-        res = exec <<-EOC
-          "\\t"
+        res = exec <<-'EOC'
+          "\t"
         EOC
         res.should == "\t"
       end
       it "should handle newline replacements" do
-        res = exec <<-EOC
-          "\\n"
+        res = exec <<-'EOC'
+          "\n"
         EOC
         res.should == "\n"
       end
       
       it "should handle double escapes" do
-        res = exec <<-EOC
-          "\\\\t"
+        res = exec <<-'EOC'
+          "\\t"
         EOC
         res.should == "\\t"
       end
       
       it "should handle double escapes followed by single escapes" do
-        res = exec <<-EOF
-          "\\\\\\t"
+        res = exec <<-'EOF'
+          "\\\t"
         EOF
         res.should == "\\\t"
       end
@@ -89,36 +89,38 @@ describe RVM::Languages::ECMA do
         EOC
         res.should == [42, "Kekse!"]
       end
+      
+      it "should allow to set array elements" do
+        res = exec <<-EOC
+          array = [];
+          array[0] = 42;
+          array;
+        EOC
+        res.should == [42]
+      end
     end
     
-    describe "associative array" do
-      it "should handle an empty associative array literals" do
+    describe "Objects array" do
+      it "should handle an empty object" do
         res = exec <<-EOC
           {}
         EOC
-        res.should == {}
+        res.should be_instance_of(RVM::Classes::Object)
       end
       
-      it "should handle an associative array literals with one element" do
+      it "should handle an object with variables" do
         res = exec <<-EOC
-          {1:2}
+          {a: 1}
         EOC
-        res.should == {1 => 2}
+        res.should be_instance_of(RVM::Classes::Object)
+        res.variables['a'].val.should == 1
       end
-      
-      it "should handle an associative array literals with multiple element" do
+      it "should handle an object with functions" do
         res = exec <<-EOC
-          {1:2, 'test' : 'toast'}
+          {f: function(){1}}
         EOC
-        res.should == {1 => 2, 'test' => 'toast'}
-      end
-      
-      it "should handle hashes within hashes" do
-        res = exec <<-EOC
-          {1:{1:2}, 'test' : 'toast'}
-        EOC
-        res.should == {1 => {1 => 2}, 'test' => 'toast'}
-        
+        res.should be_instance_of(RVM::Classes::Object)
+        res.functions.keys.should include('f')
       end
     end
     
@@ -143,16 +145,24 @@ describe RVM::Languages::ECMA do
       res = exec <<-EOC
         a[0]
       EOC
-      res.should == 1   
+      res.should == 1
+    end
+    
+    it "should allow setting elements" do
+      @env['a'] = RVM::Classes::List.new([1,2,3])
+      res = exec <<-EOC
+        a[0] = 42;
+      EOC
+      res.should == 42
+      @env['a'].val[0].should == 42
     end
-   
     it "should allow accessing the length" do
       @env['a'] = RVM::Classes::List.new([1,2,3])
       res = exec <<-EOC
         a.length()
       EOC
       res.should == 3
-    end    
+    end
   end
   
   describe "variables" do
@@ -172,6 +182,15 @@ describe RVM::Languages::ECMA do
       @env['variable'].val.should == 'value'
     end
   
+    it "should recognize multiple local assignments" do
+      res = exec <<-EOC
+        var i = 'a', j= 'b';
+      EOC
+      res.should == 'b'
+      @env['i'].val.should == 'a'
+      @env['j'].val.should == 'b'
+    end
+    
     it "should scope local assignments correctly" do
       res = exec <<-EOC
         variable = 'outer scope';
@@ -275,14 +294,22 @@ describe RVM::Languages::ECMA do
     it "should handle for loops" do
       res = exec <<-EOC
         variable = "";
-        for (i = 0; i < 3; i = i + 1) {
+        for (i = 0; i <= 3; i = i + 1) {
           variable = variable + i;
         }
       EOC
-      res.should == 3
-      @env['variable'].val.should == '012'    
+      res.should == 4
+      @env['variable'].val.should == '0123'    
     end
-  
+    
+    it "should handle for loops (bug prevention)" do
+      code =<<-EOC
+        function test() {for (var i = 1; i <= 2; i+=1) {};};
+        test();
+      EOC
+      proc { exec(code) }.should_not raise_error
+    end  
+    
     it "should handle while loops" do
       res = exec <<-EOC
         variable = "";
@@ -382,6 +409,35 @@ describe RVM::Languages::ECMA do
     end
   end
   
-  describe "condition"
-
+  
+  describe "opperators" do
+    it "should recognize ++" do
+      @env['i'] = RVM::Classes::Number.new(41) 
+      res = exec <<-EOC
+        i++;
+      EOC
+      res.should == 42
+    end
+    it "should recognize --" do
+      @env['i'] = RVM::Classes::Number.new(43) 
+      res = exec <<-EOC
+        i--;
+      EOC
+      res.should == 42
+    end
+    it "should recognize +=" do
+      @env['i'] = RVM::Classes::Number.new(40) 
+      res = exec <<-EOC
+        i += 2;
+      EOC
+      res.should == 42
+    end
+    it "should recognize -=" do
+      @env['i'] = RVM::Classes::Number.new(44) 
+      res = exec <<-EOC
+        i -= 2;
+      EOC
+      res.should == 42
+    end
+  end
 end