AmberVM 0.0.19

data/lib/amber/rails.rb

@@ -0,0 +1,90 @@
+=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 'amber/acts_as_amber_type.rb'
+
+# Inlcude the AmberVM::ACtsAsAmberVMType into active record so functions like
+# +acts_as_amber_type+ and comparable
+ActiveRecord::Base.class_eval do
+  include AmberVM::ActsAsAmberVMType
+end
+
+module ActionController #:nodoc:
+  class Base
+    # This function allows to render code that gets compiled by amber. 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 amber_render accepts 4 additioal
+    # parameters.They are the same as used in +amber_execute+.
+    def amber_reder code, options = {}
+      render options.merge({:text => amber_execute(code, options)})
+    end
+    
+    
+    # The amber_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 amber_execute code, options = {}
+      options = {
+        :language => :ecma,
+        :environment => AmberVM::Interpreter.env
+      }.merge(options)
+      compiler = AmberVM::Languages[options[:language]].new
+      code = compiler.compile(code)
+      code = AmberVM::Interpreter::ObjectContext.new(AmberVM::Interpreter::Constant.new(options[:object]), code) if options[:object]
+      if options[:environment][:render].is_a? AmberVM::Classes::Error or options[:environment][:render].nil?
+        options[:environment][:render] = ""
+      end
+      puts options[:environment][:render].inspect
+      if options[:timeout]
+        s = AmberVM::Safety.new :timeout => options[:timeout]
+        s.execute(code, options[:environment])
+      else
+        code.execute(options[:environment])
+      end
+      options[:environment][:render].val
+    end
+  end
+end
+require 'amber/functions/rails.rb'

data/lib/amber.rb

@@ -0,0 +1,106 @@
+require 'amber/interpreter'
+require 'amber/classes'
+require 'amber/functions'
+require 'amber/languages'
+require 'timeout'
+
+# This is the rVM library. Including it loads the very basic functionalites rVM offers.
+# 
+# It however does not yet load any functions or languages for security propose.
+# This will have to be done by hand for the reason that it will force the user to concider
+# which functions he wants to offer and which not.
+#
+# You may very well load your own functions and languages with rVM in the same way you can
+# load shipped languages.
+#
+# It also contains some usefull functions that wil allow to make the usuage easyer.
+module AmberVM
+  VERSION = "0.0.19" unless defined?(AmberVM::VERSION)
+
+  # This class is designed to allow execting code more safely
+  #
+  # It allows to limit executin in multiple ways to prevent all sorty of runaway code.
+  class Safety
+    
+    attr_reader :timeout
+    def initialize options = {}
+      @timeout = options[:timeout]
+    end
+    
+    # Sets the timeout for the executin, in seconds (you may use 0.5 and such)
+    # 
+    # The execution is aboarded and a exeption thrown if the 
+    def timeout=t 
+      raise ArgumentError, "The timeout must be a number!" if not t.is_a? Numeric
+      @timeout = t
+    end
+    
+    # Executes the code with the former set security measures.
+    #
+    # Exceptions are thrown according to the problem
+    def execute code, env
+      res = nil
+      if @timeout
+        Timeout::timeout(@timeout) do
+          res = code.execute(env)
+        end
+      else
+        res = code.execute(env)
+      end
+      res
+    end
+  end
+  
+  class << self
+    @@strict = false
+    
+    # This getter returns if rVM handles types strict.
+    #
+    # Calling a method with wrong types will raise a error if this is true.
+    # If false rVM will try to typecast accordingly.
+    def strict
+      @@strict
+    end
+    
+    # Sets if variables are strictly typed or casted for function calls.
+    # This allows to make a language either more secure or more flexible.
+    def strict= v
+      @@strict = v
+    end
+    
+    # Compils a code the given language.
+    # A new compiler is created for that and discarded afterwards.
+    #
+    # Using +compiler_for+ and calling compile for it yourself
+    # is more performant if you plan on doing thise more then once.
+    def compile language, code
+      compiler_for(language).compile(code)
+    end
+    
+    # Creates you a compiler object for the given language.
+    # If no language is given a error is raised.
+    def compiler_for language
+      if (l = AmberVM::Languages[language])
+        l.new
+      else
+        raise "AmberVM Error: Unknown Language #{language}"
+      end
+    end
+    
+    # A utility function to give debug output based on weather $DEBUG is set or not
+    def debug text
+      if $HTML_DEBUG
+        puts "<p><pre>" + (">>> #{text}".gsub("<","&lt;").gsub('>','&gt;').gsub("\n","<br/>\n"))+ "</pre></p>"
+      else
+        puts ">>> #{text}"
+      end
+    end
+  end
+end
+
+
+class String
+  def to_html
+    self.gsub('<','&lt;').gsub('>', '&gt;').gsub("\n", '<br/>').gsub(' ', '&nbsp;')
+  end
+end

data/spec/amber/class_spec.rb

@@ -0,0 +1,27 @@
+require 'amber/classes'
+require 'spec/amber/helpers/plugin_helper'
+require  File.dirname(__FILE__) + '/helpers/class_helper'
+
+describe AmberVM::Classes do
+  it_should_behave_like "a plugin host"
+end
+
+describe AmberVM::Classes::Class do
+  describe "(plugin)" do
+    before do
+      @object = AmberVM::Classes::Class
+    end
+    it_should_behave_like "a plugin"
+    
+  end
+  
+  describe "(class)" do
+    before do
+      @object = AmberVM::Classes::Class.new
+    end    
+    
+    it_should_behave_like "a class"
+    
+  end
+  
+end

data/spec/amber/enviroment_spec.rb

@@ -0,0 +1,61 @@
+require 'amber/interpreter'
+
+shared_examples_for "a environment" do
+  it "should get the locals" do
+    @env['1'].val.should == 'one'
+  end
+  
+  it "should return nil for unset locals" do
+    @env['2'].should == nil
+  end
+  
+  it "should allow to change locals" do
+    @env['2'] = 'two'
+    @env['2'].val.should == 'two'
+  end
+end
+
+describe AmberVM::Interpreter::Environment do
+  before :each do
+    @env = AmberVM::Interpreter::Environment.new({:params => [1,2], :locals => {'1' => 'one'}})
+  end
+  
+  it_should_behave_like "a environment"
+  
+  it "should autocast locals to variable storages on creation" do
+    env = AmberVM::Interpreter::Environment.new({:params => [1,2], :locals => {'1' => 'one'}})
+    env['1'].should be_kind_of(AmberVM::Interpreter::VariableStorage)
+  end
+  
+  it "should get the params" do
+    @env.param(0).should be(1)
+    @env.param(1).should be(2)
+  end
+  
+  it "should have a path" do
+    @env.path.should be_kind_of(Array)
+  end
+  
+  
+  describe "(parented)" do
+    before do
+      @old_env = @env
+      @env = AmberVM::Interpreter::Environment.new({}, @old_env)
+    end
+    
+    it_should_behave_like "a environment"
+
+=begin
+    it "should have the same path as it's parrent" do
+      @env.path.should be(@old_env.path)
+    end
+=end
+    it "should apply changes to already set variables to the parent" do
+      @env['1'].val.should == 'one'
+      @env['1'] = 'ONE!'
+      @env['1'].val.should == 'ONE!'
+      @old_env['1'].val.should == 'ONE!'
+    end
+    
+  end
+end

data/spec/amber/function_spec.rb

@@ -0,0 +1,25 @@
+require 'amber/functions'
+require 'spec/amber/helpers/plugin_helper'
+require  File.dirname(__FILE__) + '/helpers/function_helper'
+
+describe AmberVM::Functions do
+  it_should_behave_like "a plugin host"
+end
+
+describe AmberVM::Functions::Function do
+  describe "(plugin)" do
+    before do
+      @object = AmberVM::Functions::Function
+    end
+    it_should_behave_like "a plugin"
+    
+  end
+  
+  describe "(function)" do
+    before do
+      @object = AmberVM::Functions::Function
+    end    
+    it_should_behave_like "a function"
+  end
+  
+end

data/spec/amber/functions/association/assoc_get_spec.rb

@@ -0,0 +1,41 @@
+require 'amber/functions'
+require 'amber/functions/association/assoc_get'
+
+describe AmberVM::Functions::AssocGet do
+  before(:each) do
+    @env = mock('env mock')
+    @function = AmberVM::Functions[:assoc_get]
+  end
+  
+  it "should accept a usual function call with 2 parameters and get the value" do
+    params = [
+      p1 = mock('param 1 mock'),
+      p2 = mock('param 2 mock')
+    ]
+    res = p1.should_receive(:[]).with(p2).and_return('result')
+    @function.execute(params, @env).should == 'result'
+  end
+  
+  it "should accept a object call wiht 1 parameter and a object in env and get the value" do
+    params = [
+      p1 = mock('param 1 mock')
+    ]
+    obj = mock('association mock')
+    @env.should_receive(:read_var_val).once.with(:self).and_return(obj)
+    obj.should_receive(:is_a?).once.with(AmberVM::Classes::Association).and_return(true)
+    res = obj.should_receive(:[]).with(p1).and_return('result')
+    @function.execute(params, @env).should == 'result'
+  end
+  
+  it "should return an error with more then 2 arguments" do
+    params = [1,2,3]
+    @function.execute(params, @env).should be_an_instance_of(AmberVM::Classes::Error)
+  end
+
+  
+  it "should return an error with no arguments" do
+    params = []
+    @function.execute(params, @env).should be_an_instance_of(AmberVM::Classes::Error)
+  end
+  
+end

data/spec/amber/functions/association/assoc_set_spec.rb

@@ -0,0 +1,43 @@
+require 'amber/functions'
+require 'amber/functions/association/assoc_set'
+
+describe AmberVM::Functions::AssocSet do
+  before(:each) do
+    @env = mock('env mock')
+    @function = AmberVM::Functions[:assoc_set]
+  end
+  
+  it "should accept a usual function call with 3 parameters and return the value it sets" do
+    params = [
+      p1 = mock('param 1 mock'),
+      p2 = mock('param 2 mock'),
+      p3 = mock('param 3 mock')
+    ]
+    p1.should_receive(:[]=).with(p2, p3).and_return(p3)
+    @function.execute(params, @env).should == p3
+  end
+  
+  it "should accept a object call wiht 2 parameter and a object in env and return the value it sets" do
+    params = [
+      p1 = mock('param 1 mock'),
+      p2 = mock('param 2 mock')
+    ]
+    obj = mock('association mock')
+    @env.should_receive(:read_var_val).once.with(:self).and_return(obj)
+    obj.should_receive(:is_a?).once.with(AmberVM::Classes::Association).and_return(true)
+    res = obj.should_receive(:[]=).with(p1,p2).and_return(p2)
+    @function.execute(params, @env).should == p2
+  end
+  
+  it "should return an error with more then 4 arguments" do
+    params = [1, 2, 3, 4]
+    @function.execute(params, @env).should be_an_instance_of(AmberVM::Classes::Error)
+  end
+
+  
+  it "should return an error with less then 2 arguments" do
+    params = [1]
+    @function.execute(params, @env).should be_an_instance_of(AmberVM::Classes::Error)
+  end
+  
+end

data/spec/amber/functions/collection/get_spec.rb

@@ -0,0 +1,12 @@
+require 'amber/functions'
+require 'amber/functions/association/assoc_get'
+require 'amber/functions/array/at'
+require 'amber/functions/collection/get'
+
+describe AmberVM::Functions::Get do
+  before(:each) do
+    @env = mock('env mock')
+    @function = AmberVM::Functions[:get]
+  end
+  
+end

data/spec/amber/functions/collection/set_spec.rb

@@ -0,0 +1,10 @@
+require 'amber/functions'
+require 'amber/functions/collection/set'
+
+describe AmberVM::Functions::Set do
+  before(:each) do
+    @env = mock('env mock')
+    @function = AmberVM::Functions[:set]
+  end
+  
+end

data/spec/amber/functions/collection/size_spec.rb

@@ -0,0 +1,10 @@
+require 'amber/functions'
+require 'amber/functions/collection/size'
+
+describe AmberVM::Functions::Set do
+  before(:each) do
+    @env = mock('env mock')
+    @function = AmberVM::Functions[:set]
+  end
+  
+end

data/spec/amber/functions/list/split_spec.rb

@@ -0,0 +1,47 @@
+require 'spec/amber/helpers/plugin_helper'
+require 'spec/amber/helpers/function_helper'
+require 'amber/functions/list/split'
+
+describe AmberVM::Functions::Split do
+  
+  before do
+    @object = AmberVM::Functions::Split
+  end
+  
+  describe "(plugin)" do
+    it_should_behave_like "a plugin"
+  end
+  
+  describe "(function)" do
+    it_should_behave_like "a function"
+    
+    it "should have a signature of string, string" do
+      @object.signature.should == [AmberVM::Classes::String, AmberVM::Classes::String]
+    end
+    
+    it "should have a type of :list" do
+      @object.data_type.should == :list
+    end
+  end
+   describe "(functionality)" do
+    before do
+      @env = mock('env mock')
+      @old_db = $DB
+      $DB = mock('db mock')
+    end
+    
+    after do
+      $DB = @old_db
+    end
+    
+    it "should have tests implemented" do
+      pending "This needs to be implemented, locate functions neeeeeeeds specs."
+    end
+    
+    it "should not work with more then 3 and less the 2 params" do
+      @object.execute([1], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1,2,3,1], nil).should be_instance_of(AmberVM::Classes::Error)
+    end
+    
+  end
+end

data/spec/amber/functions/string/ansi_spec.rb

@@ -0,0 +1,44 @@
+require 'spec/amber/helpers/plugin_helper'
+require 'spec/amber/helpers/function_helper'
+require 'amber/functions/string/ansi'
+
+
+describe AmberVM::Functions::Ansi do
+  
+  before do
+    @object = AmberVM::Functions::Ansi
+  end
+  
+  describe "(plugin)" do
+    it_should_behave_like "a plugin"
+    
+  end
+  
+  describe "(function)" do
+    it_should_behave_like "a function"
+    
+    it "should have a signature of string, string" do
+      @object.signature.should == [AmberVM::Classes::String, AmberVM::Classes::String]
+    end
+    it "should have a type of boolean" do
+      @object.data_type.should == :string
+    end
+  end
+  
+  describe "(functionality)" do
+    
+    it "should not work with less then 2 params" do
+      @object.execute([], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1,2,3], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1,2,3,4], nil).should be_instance_of(AmberVM::Classes::Error)
+    end
+    
+    it "should call the ansi function for the seclond with the first argument as parameter" do
+      arg1 = mock('arg mock')
+      arg1.should_receive(:ansi).once.with(1).and_return 'one'
+      @object.execute([1,arg1], nil).should == 'one'
+    end
+  end
+  
+end

data/spec/amber/functions/string/capstr_spec.rb

@@ -0,0 +1,42 @@
+require 'spec/amber/helpers/plugin_helper'
+require 'spec/amber/helpers/function_helper'
+require 'amber/functions/string/capstr'
+
+
+describe AmberVM::Functions::Capstr do
+  
+  before do
+    @object = AmberVM::Functions::Capstr
+  end
+  
+  
+  describe "(plugin)" do
+    it_should_behave_like "a plugin"
+    
+  end
+  
+  describe "(function)" do
+    it_should_behave_like "a function"
+    
+    it "should have a signature of string" do
+      @object.signature.should == [AmberVM::Classes::String]
+    end
+    it "should have a type of boolean" do
+      @object.data_type.should == :string
+    end
+  end
+  
+  describe "(functionality)" do
+    
+    it "should not work with more or less then 1 param" do
+      @object.execute([], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1,2], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1,2,3], nil).should be_instance_of(AmberVM::Classes::Error)
+    end
+    
+    it "should capitalize the first letter" do
+      @object.execute(["abc"], nil).should == 'Abc'
+    end
+  end
+  
+end

data/spec/amber/functions/string/center_spec.rb

@@ -0,0 +1,49 @@
+require 'spec/amber/helpers/plugin_helper'
+require 'spec/amber/helpers/function_helper'
+require 'amber/functions/string/center'
+
+
+describe AmberVM::Functions::Center do
+  
+  before do
+    @object = AmberVM::Functions::Center
+  end
+  
+  describe "(plugin)" do
+    it_should_behave_like "a plugin"
+    
+  end
+  
+  describe "(function)" do
+    it_should_behave_like "a function"
+    
+    it "should have a signature of string, string" do
+      @object.signature.should == [AmberVM::Classes::String, AmberVM::Classes::Number, AmberVM::Classes::String]
+    end
+    it "should have a type of boolean" do
+      @object.data_type.should == :string
+    end
+  end
+  
+  describe "(functionality)" do
+    
+    it "should not work with less then 2 params or more then 3" do
+      @object.execute([], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1,2,3,4], nil).should be_instance_of(AmberVM::Classes::Error)
+    end
+    
+    it "should call the center function with one param if it is given" do
+      arg1 = mock('arg mock')
+      arg1.should_receive(:center).once.with(1).and_return 'center'
+      @object.execute([arg1,1], nil).should == 'center'
+    end
+    
+    it "should call the center function with one two param if they are given" do
+      arg1 = mock('arg mock')
+      arg1.should_receive(:center).once.with(1,2).and_return 'center2'
+      @object.execute([arg1,1,2], nil).should == 'center2'
+    end
+  end
+  
+end

data/spec/amber/functions/string/ljust_spec.rb

@@ -0,0 +1,49 @@
+require 'spec/amber/helpers/plugin_helper'
+require 'spec/amber/helpers/function_helper'
+require 'amber/functions/string/ljust'
+
+
+describe AmberVM::Functions::Ljust do
+  
+  before do
+    @object = AmberVM::Functions::Ljust
+  end
+  
+  describe "(plugin)" do
+    it_should_behave_like "a plugin"
+    
+  end
+  
+  describe "(function)" do
+    it_should_behave_like "a function"
+    
+    it "should have a signature of string, string" do
+      @object.signature.should == [AmberVM::Classes::String, AmberVM::Classes::Number, AmberVM::Classes::String]
+    end
+    it "should have a type of boolean" do
+      @object.data_type.should == :string
+    end
+  end
+  
+  describe "(functionality)" do
+    
+    it "should not work with less then 2 params or more then 3" do
+      @object.execute([], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1], nil).should be_instance_of(AmberVM::Classes::Error)
+      @object.execute([1,2,3,4], nil).should be_instance_of(AmberVM::Classes::Error)
+    end
+    
+    it "should call the ljust function with one param if it is given" do
+      arg1 = mock('arg mock')
+      arg1.should_receive(:ljust).once.with(1).and_return 'ljust'
+      @object.execute([arg1,1], nil).should == 'ljust'
+    end
+    
+    it "should call the ljust function with one two param if they are given" do
+      arg1 = mock('arg mock')
+      arg1.should_receive(:ljust).once.with(1,2).and_return 'ljust'
+      @object.execute([arg1,1,2], nil).should == 'ljust'
+    end
+  end
+  
+end