AmberVM 0.0.19

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

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../helpers/plugin_helper'
+require File.dirname(__FILE__) + '/../../helpers/function_helper'
+require 'amber/functions/string/regmatch'
+
+
+describe AmberVM::Functions::Regmatch do
+  
+  before do
+    @object = AmberVM::Functions::Regmatch
+  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 == :boolean
+    end
+  end
+  
+  describe "(functionality)" do
+    
+    it "should not work with exactly 2" 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 retrn an error if the param is not a valid regexp" do
+      @object.execute(['*','*'], nil).should be_instance_of(AmberVM::Classes::Error)
+    end
+    
+    it "should return true if the regular expressiom matches" do
+      @object.execute(['*','.'], nil).is_true?.should be_true
+      @object.execute(['1','\d'], nil).is_true?.should be_true
+    end
+    
+    it "should return false if the regular expression does not matches" do
+      @object.execute(['*','a'], nil).is_true?.should be_false
+      @object.execute(['abc','\d'], nil).is_true?.should be_false
+    end
+  end
+  
+end

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

@@ -0,0 +1,49 @@
+require 'spec/amber/helpers/plugin_helper'
+require 'spec/amber/helpers/function_helper'
+require 'amber/functions/string/rjust'
+
+
+describe AmberVM::Functions::Rjust do
+  
+  before do
+    @object = AmberVM::Functions::Rjust
+  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 rjust function with one param if it is given" do
+      arg1 = mock('arg mock')
+      arg1.should_receive(:rjust).once.with(1).and_return 'rjust'
+      @object.execute([arg1,1], nil).should == 'rjust'
+    end
+    
+    it "should call the rjust function with one two param if they are given" do
+      arg1 = mock('arg mock')
+      arg1.should_receive(:rjust).once.with(1,2).and_return 'rjust'
+      @object.execute([arg1,1,2], nil).should == 'rjust'
+    end
+  end
+  
+end

data/spec/amber/interpreter/assignment_spec.rb

@@ -0,0 +1,22 @@
+require 'amber/interpreter'
+
+describe AmberVM::Interpreter::Assignment do
+  before do
+    @variable = mock('variable mock')
+    @value = mock('value mock')
+    @env = mock('env mock')
+    @object = AmberVM::Interpreter::Assignment.new(@variable, @value)
+  end
+  
+  it "should have the type of it's value" do
+    @value.should_receive(:data_type).with(no_args).once.and_return(:example)
+    @object.data_type.should == :example
+  end
+  
+  it "should execute first the name then the value and store it in env" do
+    @variable.should_receive(:execute).with(@env).once.and_return(@variable)
+    @variable.should_receive(:val=).with('value').once.and_return('value')
+    @value.should_receive(:execute).with(@env).once.and_return('value')
+    @object.execute(@env).should == 'value'
+  end
+end

data/spec/amber/interpreter/condition_spec.rb

@@ -0,0 +1,103 @@
+require 'amber/interpreter'
+
+describe AmberVM::Interpreter::Condition do
+  before do
+    @true_case = mock('true case mock')
+    @false_case = mock('false case mock')
+    @condition = mock('condition mock')
+    @env = AmberVM::Interpreter.env
+    @object = AmberVM::Interpreter::Condition.new(@condition, @true_case, @false_case)
+  end
+  
+  it "should execute the condition if true execute the true case, retring it's value" do
+    result = mock('result mock')
+    result.should_receive(:is_true?).with(no_args).once.and_return(true)
+    @true_case.should_receive(:execute).with(@env).once.and_return('true case')
+    @condition.should_receive(:execute).with(@env).once.and_return(result)
+    @object.execute(@env).should == 'true case'
+  end
+  
+  it "should execute the condition if false execute the false case, retring it's value" do
+    result = mock('result mock')
+    result.should_receive(:is_true?).with(no_args).once.and_return(false)
+    @false_case.should_receive(:execute).with(@env).once.and_return('false case')
+    @condition.should_receive(:execute).with(@env).once.and_return(result)
+    @object.execute(@env).should == 'false case'
+  end
+  
+  it "should execute the condition if false and no false condition is given return nil" do
+    @object = AmberVM::Interpreter::Condition.new(@condition, @true_case)
+    result = mock('result mock')
+    result.should_receive(:is_true?).with(no_args).once.and_return(false)
+    @condition.should_receive(:execute).with(@env).once.and_return(result)
+    @object.execute(@env).should be_nil
+  end
+  
+  it "should return the type of it's cases if they are the same" do
+    @true_case.should_receive(:data_type).with(no_args).once.and_return('type1')
+    @false_case.should_receive(:data_type).with(no_args).at_least(:once).and_return('type1')
+    @object.data_type.should == 'type1'
+  end
+  
+  it "should return the :any type if the types are not the same" do
+    @true_case.should_receive(:data_type).with(no_args).once.and_return('type1')
+    @false_case.should_receive(:data_type).with(no_args).once.and_return('type2')
+    @object.data_type.should == :any
+  end
+=begin
+  
+   it "should use path 0 for the true case" do
+    result = mock('result mock')
+    result.should_receive(:is_true?).with(no_args).once.and_return(true)
+    path = mock('Path mock')
+
+    @env.should_receive(:path).twice.and_return(path)
+    path.should_receive(:<<).with(0).once
+    path.should_receive(:pop).with(no_args).once.and_return(0)
+   
+    @true_case.should_receive(:execute).with(@env).once.and_return('true case')
+    @condition.should_receive(:execute).with(@env).once.and_return(result)
+    @object.execute(@env).should == 'true case'
+  end
+  
+   it "should use path 1 for the false case" do
+    result = mock('result mock')
+    result.should_receive(:is_true?).with(no_args).once.and_return(false)
+    path = mock('Path mock')
+
+    @env.should_receive(:path).twice.and_return(path)
+    path.should_receive(:<<).with(1).once
+    path.should_receive(:pop).with(no_args).once.and_return(1)
+   
+    @false_case.should_receive(:execute).with(@env).once.and_return('false case')
+    @condition.should_receive(:execute).with(@env).once.and_return(result)
+    @object.execute(@env).should == 'false case'
+  end
+  
+=begin  
+ it "should add add a new layer to path when called" do
+    @path = mock('path mock')
+    @object = AmberVM::Interpreter::Sequence.new([@part1])
+    @part1.should_receive(:execute).with(@env, nil).once
+    @env.should_receive(:path).with(no_args).exactly(4).times.and_return(@path)
+    @path.should_receive(:<<).with(0).once
+    @path.should_receive(:pop).with(no_args).twice.and_return(0)
+    @path.should_receive(:<<).with(1).once
+    @object.execute(@env)
+  end
+  
+  it "should skip parts according to the path" do
+    @part2.should_receive(:execute).with(@env, nil).once
+    @env.should_receive(:path).with(no_args).exactly(6).times.and_return([1])
+    @object.execute(@env, [1])    
+  end
+  
+  it "should hand down the path to the next executor" do
+    @part2.should_receive(:execute).with(@env, [2]).once
+    @env.should_receive(:path).with(no_args).exactly(6).times.and_return([1])
+    @object.execute(@env, [1,2])    
+  end
+=end
+
+  
+end

data/spec/amber/interpreter/constant_spec.rb

@@ -0,0 +1,31 @@
+require 'amber/interpreter'
+
+describe AmberVM::Interpreter::Constant do
+  before do
+    @value = mock('value mock')
+    @env = AmberVM::Interpreter.env
+    @object = AmberVM::Interpreter::Constant.new(@value)
+  end
+  
+  it "should return the value when executed." do
+    @object.execute(@env).should be(@value)
+  end
+  
+  it "should have the data type of it's value" do
+    @value.should_receive(:data_type).with(no_args).once.and_return(:example)
+    @object.data_type.should == :example
+  end
+  
+  it "should compare with other constants based on the value" do
+    @object.==(@object).should be_true
+    object2 = AmberVM::Interpreter::Constant.new(@value)
+    @object.==(object2).should be_true 
+    object3 = AmberVM::Interpreter::Constant.new(1)
+    @object.==(object3).should be_false
+  end
+  
+  it "should not compare to other types" do
+    @object.==(1).should be_false
+  end
+  
+end

data/spec/amber/interpreter/core_call_spec.rb

@@ -0,0 +1,72 @@
+require 'amber/interpreter'
+require 'amber/classes/block'
+
+class CoreMock < AmberVM::Functions::Function
+  register_for :mock
+  class << self
+    def call *args
+      'result'
+    end
+    def execargs
+      @execargs
+    end
+    def data_type
+      :type
+    end
+    def execargs=v
+      @execargs =  v
+    end
+  end
+end
+
+class AmberVM::Interpreter::CoreCall
+  def fun
+    @fun
+  end
+  
+  def fun= f
+    @fun = f
+  end
+end
+
+describe AmberVM::Interpreter::CoreCall do
+  before do
+    @param1 = mock('param 1 mock')
+    @param2 = mock('param 2 mock')
+    @fun = mock('Core mock')
+    @env = mock('env mock')
+  end
+  
+  describe "(execution)" do
+    before do
+      @object = AmberVM::Interpreter::CoreCall.new(:mock, [@param1,@param2])          
+    end
+    
+    it "shold execute it's params when the Core.execargs returns true" do
+      CoreMock.execargs = true
+      @object = AmberVM::Interpreter::CoreCall.new('mock', [@param1,@param2])
+      @param1.should_receive(:execute).once.with(@env).and_return('param 1')
+      @param2.should_receive(:execute).once.with(@env).and_return('param 2')
+      @object.execute(@env).should == 'result'
+    end
+    
+    it "shold not execute it's params when the Core.execargs returns false" do
+      CoreMock.execargs = false
+      @object = AmberVM::Interpreter::CoreCall.new('mock', [@param1,@param2])
+      @object.execute(@env).should == 'result'
+    end
+    
+    it "should return the data type of the Core" do
+      @object.data_type.should == :type
+    end
+    
+    it "should not compare with random objects" do
+      @object.==(1).should be_false
+    end
+    
+    it "should compare with other Core if args and params are true it is the same" do
+      @object = AmberVM::Interpreter::CoreCall.new(:mock, [@param1,@param2])
+      @object.==(@object).should be_true
+    end
+  end
+end

data/spec/amber/interpreter/interpreter_spec.rb

@@ -0,0 +1,11 @@
+require 'amber/interpreter'
+
+describe AmberVM::Interpreter do
+  
+  it "should create a constant" do
+    c = AmberVM::Interpreter.const(:string, 'wobble')
+    c.should be_instance_of(AmberVM::Interpreter::Constant)
+    c.value.should  be_instance_of(AmberVM::Classes[:string])
+    c.value.should == 'wobble'
+  end
+end

data/spec/amber/interpreter/parameter_spec.rb

@@ -0,0 +1,24 @@
+require 'amber/interpreter'
+
+describe AmberVM::Interpreter::Parameter do
+  before do
+    @value = mock('value mock')
+    @num = mock('name mock')
+    @env = mock('env mock')
+    @object = AmberVM::Interpreter::Parameter.new(@num)
+  end
+  
+  it "should give the values type if name is a constant" do
+    @object.data_type.should == :any
+  end
+  
+  it "should return the correct value and store it's type" do
+    @num.should_receive(:execute).with(@env).once.and_return(0)
+    @env.should_receive(:param).with(0).once.and_return(@value)
+    @value.should_receive(:data_type).with(no_args).once.and_return(:type)
+    @object.execute(@env).should be(@value)
+    @object.data_type.should == :type
+  end
+  
+  
+end

data/spec/amber/interpreter/sequence_spec.rb

@@ -0,0 +1,47 @@
+require 'amber/interpreter'
+
+describe AmberVM::Interpreter::Sequence do
+=begin
+  before do
+    @part1 = mock('part1 mock')
+    @part2 = mock('part2 mock')
+    @env = mock('env mock')
+    
+    @object = AmberVM::Interpreter::Sequence.new([@part1,@part2])
+  end
+  
+  it "should execute each part after another" do
+    @part1.should_receive(:execute).with(@env, nil).once
+    @part2.should_receive(:execute).with(@env, nil).once
+    @env.should_receive(:path).with(no_args).exactly(6).times.and_return([1])
+    @object.execute(@env)
+  end
+  
+  it "should have a data_type of :any" do
+    @object.data_type.should == :any
+  end
+  
+  it "should add add a new layer to path when called" do
+    @path = mock('path mock')
+    @object = AmberVM::Interpreter::Sequence.new([@part1])
+    @part1.should_receive(:execute).with(@env, nil).once
+    @env.should_receive(:path).with(no_args).exactly(4).times.and_return(@path)
+    @path.should_receive(:<<).with(0).once
+    @path.should_receive(:pop).with(no_args).twice.and_return(0)
+    @path.should_receive(:<<).with(1).once
+    @object.execute(@env)
+  end
+  
+  it "should skip parts according to the path" do
+    @part2.should_receive(:execute).with(@env, nil).once
+    @env.should_receive(:path).with(no_args).exactly(6).times.and_return([1])
+    @object.execute(@env, [1])    
+  end
+  
+  it "should hand down the path to the next executor" do
+    @part2.should_receive(:execute).with(@env, [2]).once
+    @env.should_receive(:path).with(no_args).exactly(6).times.and_return([1])
+    @object.execute(@env, [1,2])    
+  end
+=end
+end

data/spec/amber/interpreter/variable_spec.rb

@@ -0,0 +1,24 @@
+require 'amber/interpreter'
+
+describe AmberVM::Interpreter::Variable do
+  before do
+    @value = mock('value mock')
+    @name = mock('name mock')
+    @env = mock('env mock')
+    @object = AmberVM::Interpreter::Variable.new(@name)
+  end
+  
+  it "should give the values type if name is a constant" do
+    @object.data_type.should == :any
+  end
+  
+  it "should return the correct value and store it's type" do
+    @name.should_receive(:execute).with(@env).once.and_return('name')
+    @env.should_receive(:[]).with('name').once.and_return(@value)
+    @value.should_receive(:val).with(no_args).once
+    @object.execute(@env).should be(@value)
+    @object.data_type.should == :any
+  end
+  
+  
+end

data/spec/amber/plugin_spec.rb

@@ -0,0 +1,10 @@
+require 'amber/plugin'
+require 'spec/amber/helpers/plugin_helper'
+
+describe AmberVM::PluginHost do
+    it_should_behave_like 'a plugin host'
+end
+
+describe AmberVM::Plugin do
+  it_should_behave_like 'a plugin'
+end

data/spec/classes/atom/association_spec.rb

@@ -0,0 +1,39 @@
+require 'amber/classes'
+require 'amber/classes/association'
+require 'amber/functions/association/assoc_get'
+require 'amber/functions/association/assoc_set'
+require 'amber/functions/collection/size'
+
+describe AmberVM::Classes::Association do
+  
+  before(:each) do
+    @assoc = AmberVM::Classes::Association.new
+    @assoc['key'] = 'value'
+  end  
+  
+  it "should craete with no arguments"
+  
+  it "should create with an hash"
+  
+  it "should allow you to read values" do
+    @assoc['key'].should == 'value'
+  end
+  
+  it "should allow you to write values" do
+    @assoc['key'].should == 'value'
+    @assoc['key'] = 'another value'
+    @assoc['key'].should == 'another value'
+  end
+  
+  it "should publish a get method" do
+    @assoc.functions.keys.should include('get')
+  end
+  
+  it "should publish a set method" do
+    @assoc.functions.keys.should include('set')
+  end
+  
+  it "should publich a size method" do
+    @assoc.functions.keys.should include('size')
+  end
+end

data/spec/classes/atom/block_spec.rb

@@ -0,0 +1,25 @@
+$: << 'lib'
+require 'amber/classes'
+require 'amber/interpreter'
+describe AmberVM::Classes::Block do
+  
+  before(:each) do
+    @env = AmberVM::Interpreter.env
+  end
+  
+  it "should create with a value" do
+    b = AmberVM::Classes::Block.new(nil)
+  end
+  
+  it "should return true to a execargs call" do
+    b = AmberVM::Classes::Block.new(nil)
+    b.execargs.should be_true
+  end
+  
+  it "should do nothign on execution" do
+    code = mock('code mock')
+    b = AmberVM::Classes::Block.new(code)
+    b.execute(@env).should be_nil
+  end
+  
+end

data/spec/classes/atom/boolean_spec.rb

@@ -0,0 +1,67 @@
+require "amber/classes/boolean"
+describe AmberVM::Classes::Boolean do
+  
+  
+  it "shoulds creat with a bool value" do
+    b = AmberVM::Classes::Boolean.new(true)
+    b.is_true?.should be_true
+    b = AmberVM::Classes::Boolean.new(false)
+    b.is_true?.should be_false
+  end
+  
+  it "should create with nil" do
+    b = AmberVM::Classes::Boolean.new(nil)
+    b.is_true?.should be_false
+  end
+  
+  it "should use is_true? if existing" do
+    val = mock('value mock')
+    val.should_receive(:respond_to?).once.with(:is_true?).and_return(true)
+    val.should_receive(:is_true?).once.with(no_args).and_return(false)
+    b = AmberVM::Classes::Boolean.new(val)
+    b.is_true?.should be_false 
+  end
+  
+  it "should have the data type :boolean" do
+    b = AmberVM::Classes::Boolean.new(true)
+    b.data_type.should == :boolean
+  end
+  
+  def setup
+    super
+    @Boolean = AmberVM::Classes::Boolean
+  end
+  
+  def test_class
+    assert(@Boolean)
+  end
+  
+  def test_creation
+    assert(@Boolean.new(@Boolean), "Create not nil object bool")
+  end
+  
+  def test_compare
+    assert_equal(@Boolean.new(true),@Boolean.new(true))
+    assert_equal(@Boolean.new(false),@Boolean.new(false))
+    assert_equal(@Boolean.new(false),@Boolean.new(nil))
+    assert_equal(@Boolean.new(true),@Boolean.new(self))
+  end
+  
+  def test_creation_is_true
+    assert(@Boolean)
+    assert(b1 = @Boolean.new(true), "Create true bool.")
+    assert(b2 = @Boolean.new(false), "Create false bool.")
+    assert(b3 = @Boolean.new(nil), "Create nil bool.")
+    assert(b4 = @Boolean.new(b1), "Create is_true? object bool.")
+    assert(b5 = @Boolean.new(b2), "Create not is_true? object bool.")
+    assert(b6 = @Boolean.new(@Boolean), "Create not nil object bool.")
+    
+    assert(b1.is_true?, "Test if true is true.")
+    assert(!b2.is_true?, "Test if false is false.")
+    assert(!b3.is_true?, "Test if nis is false.")
+    assert(b4.is_true?, "Test if a is_true? object is true.")
+    assert(!b5.is_true?, "Test if a not is_true? object is false.")
+    assert(b6.is_true?, "Test if not null object is true.")
+  end
+  
+end

data/spec/classes/atom/error_spec.rb

@@ -0,0 +1,43 @@
+require "amber/classes/error"
+describe AmberVM::Classes::Error do
+  
+  describe "(creation)" do
+    
+    it "should create with an integer" do
+      e = AmberVM::Classes::Error.new(1,"Test error")
+      e.should be
+    end
+    
+    it "should create with an integer" do
+      e = AmberVM::Classes::Error.new(1.2,"Test error")
+      e.should be
+    end
+    
+    it "should create with with odd stuff" do
+      e = AmberVM::Classes::Error.new(nil,"Test error")
+      e.should be
+      e = AmberVM::Classes::Error.new("muhaha","Test error")
+      e.should be
+    end
+    
+  end
+  
+  describe "(usage)" do
+    it "shuld convert to a error string" do
+      e = AmberVM::Classes::Error.new(1,"Test error.")
+      e.to_s.should == "#1 Test error."
+    end
+    
+    it "should prevent double positive error numbers" do
+      e = AmberVM::Classes::Error.new(-3,"Test error.")
+      e.to_s.should == "#-3 Test error."
+    end
+    
+    it "should return false for is_true?." do
+      e = AmberVM::Classes::Error.new(1,"Test error.")
+      e.is_true?.should be_false
+    end
+    
+  end
+  
+end