skeem 0.0.23 → 0.0.24

data/spec/skeem/s_expr_nodes_spec.rb

@@ -1,263 +1,12 @@
 require 'ostruct'
 require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/runtime'
 require_relative '../../lib/skeem/s_expr_nodes' # Load the classes under test
 
 module Skeem
-  describe SkmElement do
-    let(:pos) {double('fake-position') }
-    subject { SkmElement.new(pos) }
-
-    context 'Initialization:' do
-      it 'should be initialized with a position' do
-        expect { SkmElement.new(pos) }.not_to raise_error
-      end
-
-      it 'should know its position' do
-        expect(subject.position).to eq(pos)
-      end
-
-      # Default (overridable) behavior of SkmElement
-      it 'should react by default to predicates' do
-        expect(subject).not_to be_boolean
-        expect(subject).not_to be_number
-        expect(subject).not_to be_real
-        expect(subject).not_to be_integer
-        expect(subject).not_to be_string
-        expect(subject).not_to be_symbol
-      end
-    end # context
-  end # describe
-
-describe SkmTerminal do
-    let(:pos) { double('fake-position') }
-    let(:dummy_symbol) { double('fake-symbol') }
-    let(:sample_value) { 'sample-value' }
-    let(:dummy_token) do
-      obj = OpenStruct.new
-      obj.terminal = dummy_symbol
-      obj.lexeme = sample_value
-      obj
-    end
-    subject { SkmTerminal.new(dummy_token, pos) }
-
-    context 'Initialization:' do
-      it 'should be initialized with a token and a position' do
-        expect { SkmTerminal.new(dummy_token, pos) }.not_to raise_error
-      end
-
-      it 'should know its token' do
-        expect(subject.token).to eq(dummy_token)
-      end
-
-      it 'should know its value' do
-        expect(subject.value).to eq(sample_value)
-      end
-
-      it "should know the token's symbol" do
-        expect(subject.symbol).to eq(dummy_symbol)
-      end
-    end
-
-    context 'Provided services:' do
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq("<Skeem::SkmTerminal: sample-value>")
-      end
-    end # context
-  end # describe
-
-describe SkmBoolean do
-    let(:pos) { double('fake-position') }
-    let(:dummy_symbol) { double('BOOLEAN') }
-    let(:sample_value) { false }
-    let(:dummy_token) do
-      obj = OpenStruct.new
-      obj.terminal = dummy_symbol
-      obj.lexeme = sample_value
-      obj
-    end
-    subject { SkmBoolean.new(dummy_token, pos) }
-
-    context 'Initialization:' do
-      it 'should be initialized with a token and a position' do
-        expect { SkmBoolean.new(dummy_token, pos) }.not_to raise_error
-      end
-
-      it 'should react positively to boolean? predicate' do
-        expect(subject).to be_boolean
-      end
-    end
-
-    context 'Provided services:' do
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmBoolean: false>')
-      end
-    end # context
-  end # describe
-
-describe SkmNumber do
-    let(:pos) { double('fake-position') }
-    let(:dummy_symbol) { double('dummy') }
-    let(:sample_value) { 0.5100 }
-    let(:dummy_token) do
-      obj = OpenStruct.new
-      obj.terminal = dummy_symbol
-      obj.lexeme = sample_value
-      obj
-    end
-    subject { SkmNumber.new(dummy_token, pos) }
-
-    context 'Initialization:' do
-      it 'should be initialized with a token and a position' do
-        expect { SkmNumber.new(dummy_token, pos) }.not_to raise_error
-      end
-    end
-
-    context 'Provided services:' do
-      it 'should react positively to number? predicate' do
-        expect(subject).to be_number
-      end
-
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmNumber: 0.51>')
-      end
-    end # context
-  end # describe
-
-describe SkmReal do
-    let(:pos) { double('fake-position') }
-    let(:dummy_symbol) { double('dummy') }
-    let(:sample_value) { 0.5100 }
-    let(:dummy_token) do
-      obj = OpenStruct.new
-      obj.terminal = dummy_symbol
-      obj.lexeme = sample_value
-      obj
-    end
-    subject { SkmReal.new(dummy_token, pos) }
-
-    context 'Provided services:' do
-      it 'should react positively to number? predicate' do
-        expect(subject).to be_number
-      end
-
-      it 'should react positively to real? predicate' do
-        expect(subject).to be_real
-      end
-    end
-  end # describe
-
-describe SkmInteger do
-    let(:pos) { double('fake-position') }
-    let(:dummy_symbol) { double('dummy') }
-    let(:sample_value) { 3 }
-    let(:dummy_token) do
-      obj = OpenStruct.new
-      obj.terminal = dummy_symbol
-      obj.lexeme = sample_value
-      obj
-    end
-    subject { SkmInteger.new(dummy_token, pos) }
-
-    context 'Provided services:' do
-      it 'should react positively to number? predicate' do
-        expect(subject).to be_number
-      end
-
-      it 'should react positively to real? predicate' do
-        expect(subject).to be_real
-      end
-
-      it 'should react positively to integer? predicate' do
-        expect(subject).to be_real
-      end
-    end
-  end # describe
-
-describe SkmString do
-    let(:pos) { double('fake-position') }
-    let(:dummy_symbol) { double('dummy') }
-    let(:sample_value) { 'Hello' }
-    let(:dummy_token) do
-      obj = OpenStruct.new
-      obj.terminal = dummy_symbol
-      obj.lexeme = sample_value
-      obj
-    end
-    subject { SkmString.new(dummy_token, pos) }
-
-    context 'Provided services:' do
-      it 'should react positively to string? predicate' do
-        expect(subject).to be_string
-      end
-
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmString: Hello>')
-      end
-    end
-  end # describe
-
-describe SkmIdentifier do
-    let(:pos) { double('fake-position') }
-    let(:dummy_symbol) { double('dummy') }
-    let(:sample_value) { 'this-is-it!' }
-    let(:dummy_token) do
-      obj = OpenStruct.new
-      obj.terminal = dummy_symbol
-      obj.lexeme = sample_value
-      obj
-    end
-    subject { SkmIdentifier.new(dummy_token, pos) }
-
-    context 'Provided services:' do
-      it 'should react positively to symbol? predicate' do
-        expect(subject).to be_symbol
-      end
-
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmIdentifier: this-is-it!>')
-      end
-    end # context
-  end # describe
-
-  describe SkmList do
-    let(:sample_members) { [1, 2, 3] }
-
-    subject { SkmList.new(sample_members) }
-
-    context 'Initialization:' do
-      it 'should be initialized with its members' do
-        expect{ SkmList.new(sample_members) }.not_to raise_error
-      end
-
-      it 'should know its members' do
-        expect(subject.members).to eq(sample_members)
-        
-        other = SkmList.new([])
-        expect(other.members).to be_empty
-      end
-    end # context
-
-    context 'Provided services:' do
-      it 'should retrieve its first member' do
-        expect(subject.first).to eq(1)
-        expect(subject.head).to eq(1)
-      end
-
-      it 'should retrieve its tail members' do
-        expect(subject.tail.inspect).to eq('<Skeem::SkmList: 2, 3>')
-        expect(subject.rest.inspect).to eq('<Skeem::SkmList: 2, 3>')
-      end
-
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmList: 1, 2, 3>')
-      end
-    end # context
-  end # describe
-
-
   describe SkmDefinition do
     let(:pos) { double('fake-position') }
-    let(:sample_symbol) { SkmIdentifier.create('this-is-it!') }
+    let(:sample_symbol) { SkmIdentifier.create('ten') }
     let(:sample_expr) { SkmInteger.create(10) }
 
     subject { SkmDefinition.new(pos, sample_symbol, sample_expr) }
@@ -277,34 +26,23 @@ describe SkmIdentifier do
     end # context
 
     context 'Provided services:' do
-      it 'should return its text representation' do
-        txt1 = '<Skeem::SkmDefinition: <Skeem::SkmIdentifier: this-is-it!>,'
-        txt2 = ' <Skeem::SkmInteger: 10>>'
-        expect(subject.inspect).to eq(txt1 + txt2)
-      end
-    end # context
-  end # describe
-
-  describe SkmVariableReference do
-    let(:pos) { double('fake-position') }
-    let(:sample_symbol) { SkmIdentifier.create('this-is-it!') }
-
-    subject { SkmVariableReference.new(pos, sample_symbol) }
+      let(:runtime) { Runtime.new(Environment.new) }
 
-    context 'Initialization:' do
-      it 'should be initialized with a position and a symbol' do
-        expect{ SkmVariableReference.new(pos, sample_symbol) }.not_to raise_error
+      it 'should create an entry when evaluating' do
+        expect(runtime).not_to include(sample_symbol)
+        subject.evaluate(runtime)
+        expect(runtime).to include(sample_symbol)
       end
-
-      it 'should know its variable' do
-        expect(subject.variable).to eq(sample_symbol)
+      
+      it 'should quasiquote its variable and expression' do
+        alter_ego = subject.quasiquote(runtime)
+        expect(alter_ego).to eq(subject)        
       end
-    end # context
 
-    context 'Provided services:' do
       it 'should return its text representation' do
-        txt1 = '<Skeem::SkmVariableReference: <Skeem::SkmIdentifier: this-is-it!>>'
-        expect(subject.inspect).to eq(txt1)
+        txt1 = '<Skeem::SkmDefinition: <Skeem::SkmIdentifier: ten>,'
+        txt2 = ' <Skeem::SkmInteger: 10>>'
+        expect(subject.inspect).to eq(txt1 + txt2)
       end
     end # context
   end # describe
@@ -383,7 +121,7 @@ describe SkmIdentifier do
     let(:s_body) do { defs: s_defs, sequence: s_sequence } end
 
     subject { SkmLambda.new(pos, s_formals, s_body) }
-    
+
     context 'Initialization:' do
       it 'should be initialized with a pos and 3 expressions' do
         expect{ SkmLambda.new(pos, s_formals, s_body) }.not_to raise_error

data/spec/skeem/skm_compound_datum_spec.rb

@@ -0,0 +1,132 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/datum_dsl'
+require_relative '../../lib/skeem/skm_compound_datum' # Load the classes under test
+
+module Skeem
+  describe SkmCompoundDatum do
+    include DatumDSL
+
+    let(:sample_members) { [1, 2, 3] }
+    let(:sample_members) { [integer(1), integer(2), integer(3)] }
+    subject { SkmCompoundDatum.new(sample_members) }
+
+    context 'Initialization:' do
+      it 'should be initialized with its members' do
+        expect{ SkmCompoundDatum.new(sample_members) }.not_to raise_error
+      end
+
+      it 'should know its members' do
+        expect(subject.members).to eq(sample_members)
+
+        other = SkmCompoundDatum.new([])
+        expect(other.members).to be_empty
+      end
+    end # context
+
+    context 'Provided basic services:' do
+      it 'should assert that it is equal to itself' do
+        expect(subject).to eq(subject)
+      end
+
+     it 'should assert the equality by member values' do
+        # Comparison with other instances
+        expect(subject).to eq(SkmCompoundDatum.new(sample_members))
+        expect(subject).not_to eq(SkmCompoundDatum.new([]))
+        expect(subject).not_to eq(SkmCompoundDatum.new(sample_members.rotate))
+
+        # Comparison with array of values
+        expect(subject).to eq(sample_members)
+        expect(subject).not_to eq(sample_members.rotate)
+      end
+
+      it 'should respond to visitor' do
+        visitor = double('fake-visitor')
+        expect(visitor).to receive(:visit_compound_datum).with(subject)
+        expect { subject.accept(visitor) }.not_to raise_error
+      end
+      
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmCompoundDatum: <Skeem::SkmInteger: 1>,'
+        txt2 = '<Skeem::SkmInteger: 2>, <Skeem::SkmInteger: 3>>'
+        expect(subject.inspect).to eq(txt1 + ' ' + txt2)
+      end     
+    end # context
+
+    context 'Provided runtime services:' do
+      let(:quirk_datum) { double('two') }
+      let(:quirk_members) { [integer(1), quirk_datum, integer(3)] }
+      let(:runtime) { double('fake-runtime') }
+
+      it 'should evaluate its members' do
+        # subject contains simple literals
+        expect(subject.evaluate(runtime)).to eq(subject)
+
+        # Check that members receive the 'evaluate' message
+        expect(quirk_datum).to receive(:evaluate).with(runtime).and_return(integer(2))
+        instance = SkmCompoundDatum.new(quirk_members)
+        expect(instance.evaluate(runtime)).to eq(subject)
+      end
+
+      it 'should quasiquoting its members' do
+        # subject contains simple literals
+        expect(subject.quasiquote(runtime)).to eq(subject)
+
+        # Check that members receive the 'quasiquote' message
+        expect(quirk_datum).to receive(:quasiquote).with(runtime).and_return(integer(2))
+        instance = SkmCompoundDatum.new(quirk_members)
+        expect(instance.quasiquote(runtime)).to eq(subject)
+      end
+    end # context
+  end # describe
+
+  describe SkmList do
+    let(:sample_members) { [1, 2, 3] }
+    subject { SkmList.new(sample_members) }
+
+    context 'Initialization:' do
+      it 'should be initialized with its members' do
+        expect{ SkmList.new(sample_members) }.not_to raise_error
+      end
+      
+      it 'should react positively to list? predicate' do
+        expect(subject).to be_list
+      end
+
+      it 'should react correctly to null? predicate' do
+        expect(subject).not_to be_null
+        expect(SkmList.new([])).to be_null
+      end      
+    end # context
+
+    context 'Provided services:' do
+      it 'should retrieve its first member' do
+        expect(subject.first).to eq(1)
+        expect(subject.head).to eq(1)
+      end
+
+      it 'should retrieve its tail members' do
+        expect(subject.tail.inspect).to eq('<Skeem::SkmList: 2, 3>')
+        expect(subject.rest.inspect).to eq('<Skeem::SkmList: 2, 3>')
+      end
+
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq('<Skeem::SkmList: 1, 2, 3>')
+      end
+    end # context
+  end # describe
+  
+  describe SkmVector do
+    let(:sample_members) { [1, 2, 3] }
+    subject { SkmVector.new(sample_members) }
+
+    context 'Initialization:' do
+      it 'should be initialized with its members' do
+        expect{ SkmVector.new(sample_members) }.not_to raise_error
+      end
+      
+      it 'should react positively to vector? predicate' do
+        expect(subject).to be_vector
+      end      
+    end # context
+  end # describe
+end # module

data/spec/skeem/skm_element_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/skm_element' # Load the class under test
+
+module Skeem
+  describe SkmElement do
+    let(:pos) { double('fake-position') }
+    subject { SkmElement.new(pos) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a position' do
+        expect { SkmElement.new(pos) }.not_to raise_error
+      end
+
+      it 'should know its position' do
+        expect(subject.position).to eq(pos)
+      end
+
+      # Default (overridable) behavior of SkmElement
+      it 'should react by default to predicates' do
+        expect(subject).not_to be_boolean
+        expect(subject).not_to be_number
+        expect(subject).not_to be_real
+        expect(subject).not_to be_integer
+        expect(subject).not_to be_string
+        expect(subject).not_to be_symbol
+        expect(subject).not_to be_list
+        expect(subject).not_to be_null
+        expect(subject).not_to be_vector
+      end
+    end # context
+
+    context 'Provided services:' do
+      let(:runtime) { double('fake-runtime') }
+      let(:visitor) { double('fake-visitor') }
+      let(:not_implemented) { NotImplementedError }
+
+      it "should complain when receiving 'evaluate' message" do
+        expect { subject.evaluate(runtime) }.to raise_error(not_implemented)
+      end
+
+      it "should complain when receiving 'quasiquote' message" do
+        expect { subject.quasiquote(runtime) }.to raise_error(not_implemented)
+      end
+
+      it "should complain when receiving 'accept' message" do
+        expect { subject.accept(visitor) }.to raise_error(not_implemented)
+      end
+    end # context
+  end # describe
+end # module