rVM 0.0.10 → 0.0.11

data/spec/base/class_spec.rb

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

data/spec/base/function_spec.rb

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

data/spec/base/interpreter/assignment_spec.rb

@@ -0,0 +1,22 @@
+require 'lib/rvm/interpreter'
+
+describe RVM::Interpreter::Assignment do
+  before do
+    @name = mock('name mock')
+    @value = mock('value mock')
+    @env = mock('env mock')
+    @object = RVM::Interpreter::Assignment.new(@name, @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
+    @name.should_receive(:execute).with(@env).once.and_return('name')
+    @value.should_receive(:execute).with(@env).once.and_return('value')
+    @env.should_receive(:[]=).with('name','value').once
+    @object.execute(@env).should == 'value'
+  end
+end

data/spec/base/interpreter/condition_spec.rb

@@ -0,0 +1,47 @@
+require 'lib/rvm/interpreter'
+
+describe RVM::Interpreter::Condition do
+  before do
+    @true_case = mock('true case mock')
+    @false_case = mock('false case mock')
+    @condition = mock('condition mock')
+    @env = RVM::Interpreter.env
+    @object = RVM::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 = RVM::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
+end

data/spec/base/interpreter/constant_spec.rb

@@ -0,0 +1,31 @@
+require 'lib/rvm/interpreter'
+
+describe RVM::Interpreter::Constant do
+  before do
+    @value = mock('value mock')
+    @env = RVM::Interpreter.env
+    @object = RVM::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 = RVM::Interpreter::Constant.new(@value)
+    @object.==(object2).should be_true 
+    object3 = RVM::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/base/interpreter/enviroment_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__)  + '/../../../lib/rvm/interpreter'
+
+shared_examples_for "a enviroment" 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 RVM::Interpreter::Enviroment do
+  before :each do
+    @env = RVM::Interpreter::Enviroment.new({:params => [1,2], :locals => {'1' => 'one'}})
+  end
+  
+  it_should_behave_like "a enviroment"
+  
+  it "should autocast locals to variable storages on creation" do
+    env = RVM::Interpreter::Enviroment.new({:params => [1,2], :locals => {'1' => 'one'}})
+    env['1'].should be_kind_of(RVM::Interpreter::VariableStorage)
+  end
+  
+  it "should get the params" do
+    @env.param(0).should be(1)
+    @env.param(1).should be(2)
+  end
+  
+  describe "(parented)" do
+    before do
+      @old_env = @env
+      @env = RVM::Interpreter::Enviroment.new({}, @old_env)
+    end
+    
+    it_should_behave_like "a enviroment"
+    
+    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/base/interpreter/function_call_spec.rb

@@ -0,0 +1,72 @@
+require 'lib/rvm/interpreter'
+require 'lib/rvm/classes/block'
+
+class FunctionMock < RVM::Functions::Function
+  register_for :mock
+  class << self
+    def call *args
+      'result'
+    end
+    def execargs
+      @execargs
+    end
+    def execargs=v
+      @execargs =  v
+    end
+  end
+end
+
+class RVM::Interpreter::FunctionCall
+  def fun
+    @function
+  end
+  def fun= f
+    @function = f
+  end
+end
+
+describe RVM::Interpreter::FunctionCall do
+  before do
+    @param1 = mock('param 1 mock')
+    @param2 = mock('param 2 mock')
+    @function = mock('function mock')
+    @env = mock('env mock')
+  end
+
+  
+  describe "(execution)" do
+    before do
+      @object = RVM::Interpreter::FunctionCall.new(@function, [@param1,@param2])          
+    end
+    
+    it "shold execute it's params when the function.execargs returns true" do
+      FunctionMock.execargs = true
+      @object = RVM::Interpreter::FunctionCall.new('mock', [@param1,@param2])
+      @env.should_receive(:function).once.with('mock').and_return(nil)
+      @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 function.execargs returns false" do
+      FunctionMock.execargs = false
+      @object = RVM::Interpreter::FunctionCall.new('mock', [@param1,@param2])
+      @env.should_receive(:function).once.with('mock').and_return(nil)
+      @object.execute(@env).should == 'result'
+    end
+    
+    it "should return the data type of the function" do
+      @function.should_receive(:data_type).once.with(no_args).and_return(:type)
+      @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 function if args and params are true it is the same" do
+      @object = RVM::Interpreter::FunctionCall.new(:mock, [@param1,@param2])
+      @object.==(@object).should be_true
+    end
+  end
+end

data/spec/base/interpreter/interpreter_spec.rb

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

data/spec/base/interpreter/parameter_spec.rb

@@ -0,0 +1,24 @@
+require 'lib/rvm/interpreter'
+
+describe RVM::Interpreter::Parameter do
+  before do
+    @value = mock('value mock')
+    @num = mock('name mock')
+    @env = mock('env mock')
+    @object = RVM::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/base/interpreter/sequence_spec.rb

@@ -0,0 +1,20 @@
+require 'lib/rvm/interpreter'
+
+describe RVM::Interpreter::Sequence do
+  before do
+    @part1 = mock('part1 mock')
+    @part2 = mock('part2 mock')
+    @env = mock('env mock')
+    @object = RVM::Interpreter::Sequence.new([@part1,@part2])
+  end
+  
+  it "should execute each part after another" do
+    @part1.should_receive(:execute).with(@env).once
+    @part2.should_receive(:execute).with(@env).once
+    @object.execute(@env)
+  end
+  
+  it "should have a data_type of :any" do
+    @object.data_type.should == :any
+  end
+end

data/spec/base/interpreter/variable_spec.rb

@@ -0,0 +1,24 @@
+require 'lib/rvm/interpreter'
+
+describe RVM::Interpreter::Variable do
+  before do
+    @value = mock('value mock')
+    @name = mock('name mock')
+    @env = mock('env mock')
+    @object = RVM::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(:read_var_val).with('name').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/base/plugin_spec.rb

@@ -0,0 +1,10 @@
+require 'lib/rvm/plugin'
+require  File.dirname(__FILE__) + '/helpers/plugin_helper'
+
+describe RVM::PluginHost do
+    it_should_behave_like 'a plugin host'
+end
+
+describe RVM::Plugin do
+  it_should_behave_like 'a plugin'
+end

data/spec/classes/atom/association_spec.rb

@@ -0,0 +1,39 @@
+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'
+
+describe RVM::Classes::Association do
+  
+  before(:each) do
+    @assoc = RVM::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.should include('get')
+  end
+  
+  it "should publish a set method" do
+    @assoc.functions.should include('set')
+  end
+  
+  it "should publich a size method" do
+    @assoc.functions.should include('size')
+  end
+end

data/spec/classes/atom/block_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) +'/../../../lib/rvm/classes'
+describe RVM::Classes::Block do
+  
+  it "should create with a value" do
+    b = RVM::Classes::Block.new(nil)
+  end
+  
+  it "should return true to a execargs call" do
+    b = RVM::Classes::Block.new(nil)
+    b.execargs.should be_true
+  end
+  
+  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
+  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)
+  end
+end