skeem 0.0.23 → 0.0.24

data/lib/skeem/skm_expression.rb

@@ -0,0 +1,7 @@
+require_relative 'skm_element'
+
+module Skeem
+  # Abstract class.
+  class SkmExpression < SkmElement
+  end # class
+end # module

data/lib/skeem/skm_simple_datum.rb

@@ -0,0 +1,132 @@
+require_relative 'skm_element'
+
+module Skeem
+  # Abstract class. Root of class hierarchy needed for Interpreter
+  # design pattern
+  class SkmSimpleDatum < SkmElement
+    attr_reader :token
+    attr_reader :value
+
+    def initialize(aToken, aPosition)
+      super(aPosition)
+      @token = aToken
+      init_value(aToken.lexeme)
+    end
+
+    def self.create(aValue)
+      lightweight = self.allocate
+      lightweight.init_value(aValue)
+      return lightweight
+    end
+
+    def symbol()
+      token.terminal
+    end
+
+    # Equality operator.
+    # Returns true when: self and 'other' are identical, or
+    # when they have same value
+    # @param other [SkmSimpleDatum, Object] object to compare with.
+    # @return [TrueClass, FalseClass]
+    def ==(other)
+      return true if self.equal?(other)
+
+      result = if other.kind_of?(SkmSimpleDatum)
+          self.value == other.value
+        else
+          self.value == other
+        end
+
+      result
+    end
+
+    def done!()
+      # Do nothing
+    end
+
+    # Evaluate the Skeem expression represented by this object.
+    # Reminder: terminals evaluate to themselves.
+    # @param _runtime [Skeem::Runtime]
+    def evaluate(_runtime)
+      return self
+    end
+
+    # Return this object un-evaluated.
+    # Reminder: As terminals are atomic, there is no need to launch a visitor.
+    # @param _runtime [Skeem::Runtime]
+    def quasiquote(runtime)
+      evaluate(runtime)
+    end
+
+    # Part of the 'visitee' role in Visitor design pattern.
+    # @param _visitor [SkmElementVisitor] the visitor
+    def accept(aVisitor)
+      aVisitor.visit_simple_datum(self)
+    end
+
+    # This method can be overriden
+    def init_value(aValue)
+      @value = aValue
+    end
+
+    protected
+
+    def inspect_specific
+      value.to_s
+    end
+  end # class
+
+
+  class SkmBoolean < SkmSimpleDatum
+    def boolean?
+      true
+    end
+  end # class
+
+  class SkmNumber < SkmSimpleDatum
+    def number?
+      true
+    end
+  end # class
+
+  class SkmReal < SkmNumber
+    def real?
+      true
+    end
+  end # class
+
+  class SkmInteger < SkmReal
+    def integer?
+      true
+    end
+  end # class
+
+  class SkmString < SkmSimpleDatum
+    # Override
+    def init_value(aValue)
+      super(aValue.dup)
+    end
+
+    def string?
+      true
+    end
+    
+    def length
+      value.length
+    end
+  end # class
+
+  class SkmIdentifier < SkmSimpleDatum
+    # Override
+    def init_value(aValue)
+      super(aValue.dup)
+    end
+
+    def symbol?
+      true
+    end
+  end # class
+
+  class SkmReserved < SkmIdentifier
+  end # class
+end # module

data/lib/skeem/skm_unary_expression.rb

@@ -0,0 +1,107 @@
+require_relative 'skm_expression'
+
+module Skeem
+  class SkmUnaryExpression < SkmExpression
+    attr_reader :child
+
+    def initialize(aPosition, aChild)
+      super(aPosition)
+      @child = aChild
+    end
+
+    # Part of the 'visitee' role in Visitor design pattern.
+    # @param _visitor [SkmElementVisitor] the visitor
+    def accept(aVisitor)
+      aVisitor.visit_unary_expression(self)
+    end
+
+    protected
+
+    def inspect_specific
+      child.inspect
+    end
+  end # class
+
+  class SkmQuotation < SkmUnaryExpression
+    alias datum child
+
+    def initialize(aDatum)
+      super(nil, aDatum)
+    end
+
+    def evaluate(aRuntime)
+      datum
+    end
+
+    def quasiquote(aRuntime)
+      quasi_child = child.quasiquote(aRuntime)
+      if quasi_child.equal?(child)
+        self
+      else
+        self.class.new(quasi_child)
+      end
+    end
+
+    protected
+
+    def inspect_specific
+      datum.inspect
+    end
+
+  end # class
+
+  class SkmQuasiquotation < SkmQuotation
+    alias template child
+
+    def evaluate(aRuntime)
+      quasiquote(aRuntime)
+    end
+
+    def quasiquote(aRuntime)
+      child.quasiquote(aRuntime)
+    end
+
+  end # class
+
+  class SkmUnquotation < SkmUnaryExpression
+    alias template child
+
+    def initialize(aTemplate)
+      super(nil, aTemplate)
+    end
+
+    def evaluate(aRuntime)
+      template.evaluate(aRuntime)
+    end
+
+    def quasiquote(aRuntime)
+      result = evaluate(aRuntime)
+      result
+    end
+
+    protected
+
+    def inspect_specific
+      template.inspect
+    end
+  end # class
+
+  class SkmVariableReference  < SkmUnaryExpression
+    alias variable child
+
+    def evaluate(aRuntime)
+      var_key = variable.evaluate(aRuntime)
+      aRuntime.evaluate(var_key)
+    end
+
+    def quasiquote(aRuntime)
+      self
+    end
+
+    # Confusing!
+    # Value, here, means the value of the identifier (the variable's name).
+    def value()
+      variable.value
+    end
+  end # class
+end # module

data/lib/skeem/standard/base.skm

@@ -18,11 +18,11 @@
       #t
       #f)))
 
-; For backwards compatibility      
+; For backwards compatibility
 (define modulo
   (lambda (x y)
     (floor-remainder x y)))
-      
+
 (define odd?
   (lambda (n)
     (if (= (modulo n 2) 1)
@@ -44,6 +44,6 @@
 (define square
   (lambda (z)
     (* z z)))
-    
+
 (define list
   (lambda args args))

data/lib/skeem/tokenizer.rb

@@ -20,10 +20,12 @@ module Skeem
 
     @@lexeme2name = {
       "'" => 'APOSTROPHE',
-      '`' => 'BACKQUOTE',
+      '`' => 'GRAVE_ACCENT',
       '(' => 'LPAREN',
       ')' => 'RPAREN',
       '.' => 'PERIOD',
+      ',' => 'COMMA',
+      ',@' =>  'COMMA_AT_SIGN',
       '#(' => 'VECTOR_BEGIN'
     }.freeze
 
@@ -33,7 +35,10 @@ module Skeem
       DEFINE
       IF
       LAMBDA
+      QUASIQUOTE
       QUOTE
+      UNQUOTE
+      UNQUOTE-SPLICING
     ].map { |x| [x, x] } .to_h
 
     class ScanError < StandardError; end
@@ -78,6 +83,8 @@ module Skeem
         token = build_token(@@lexeme2name[curr_ch], scanner.getch)
       elsif (lexeme = scanner.scan(/(?:\.)(?=\s)/)) # Single char occurring alone
         token = build_token('PERIOD', lexeme)
+      elsif (lexeme = scanner.scan(/,@?/))
+        token = build_token(@@lexeme2name[lexeme], lexeme)
       elsif (lexeme = scanner.scan(/#(?:(?:true)|(?:false)|(?:u8)|[\\\(tfeiodx]|(?:\d+[=#]))/))
         token = cardinal_token(lexeme)        
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?=\s|[|()";]|$)/))

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.23'.freeze
+  VERSION = '0.0.24'.freeze
 end

data/spec/skeem/datum_dsl_spec.rb

@@ -0,0 +1,191 @@
+require_relative '../spec_helper'
+
+
+# Load the module under test
+require_relative '../../lib/skeem/datum_dsl'
+
+module Skeem
+  describe DatumDSL do
+    subject do
+      obj = Object.new
+      obj.extend(DatumDSL) # use the mixin module
+      obj
+    end
+
+    let(:boolean_tests) do
+      [
+        [true, true],
+        ['true', true],
+        ['#t', true],
+        ['#true', true],
+        [false, false],
+        ['false', false],
+        ['#f', false],
+        ['false', false]
+      ]
+    end
+    
+    let(:integer_tests) do
+      [
+        [0, 0],
+        [-123, -123],
+        [+456, 456],
+        ['0', 0],
+        ['-123', -123],
+        ['+456', 456]
+      ]      
+    end
+
+    let(:real_tests) do    
+      [
+        [0, 0],
+        [-123.4, -123.4],
+        [+456.7, 456.7],
+        [-1.234e+3, -1234],
+        ['0', 0],
+        ['-123.4', -123.4],
+        ['+456.7', 456.7],
+        ['-1.234e+3', -1234]
+      ]
+    end
+    
+    let(:string_tests) do    
+      [
+        ['hello', 'hello']
+      ]    
+    end
+    
+    let(:identifier_tests) do    
+      [
+        ['define', 'define'],
+        [SkmString.create('positive?'), 'positive?']
+      ]    
+    end
+
+    let(:simple_datum_tests) do
+      [
+        ['#t', SkmBoolean.create(true)],
+        [-1, SkmInteger.create(-1)],
+        [1.41, 1.41],
+        ['foo', 'foo']
+      ]
+    end
+
+    context 'Simple datums:' do
+      it 'should convert boolean literals' do
+        boolean_tests.each do |(literal, predicted)|
+          expect(subject.boolean(literal)).to eq(predicted)
+        end
+      end
+
+      it 'should convert integer literals' do
+        integer_tests.each do |(literal, predicted)|
+          expect(subject.integer(literal)).to eq(predicted)
+        end
+      end
+
+      it 'should convert real number literals' do
+        real_tests.each do |(literal, predicted)|
+          expect(subject.real(literal)).to eq(predicted)
+        end
+      end
+
+      it 'should convert string literals' do
+        string_tests.each do |(literal, predicted)|
+          expect(subject.string(literal)).to eq(predicted)
+        end
+      end
+
+      it 'should convert identifier literals' do
+        identifier_tests.each do |(literal, predicted)|
+          expect(subject.identifier(literal)).to eq(predicted)
+        end
+      end
+    end # context
+    
+    
+    context 'Compound datums:' do
+      it 'should convert empty array into one-member list' do 
+        result = subject.list([])
+        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_null      
+      end
+      
+      it 'should convert array of simple datums into list' do
+        literals = simple_datum_tests.map { |(datum, _predicted)| datum }
+        predictions = simple_datum_tests.map { |(_datum, predicted)| predicted }
+        list_result = subject.list(literals)
+        expect(list_result).to be_kind_of(SkmList)
+        list_result.members.each_with_index do |member, index|
+          expect(member).to eq(predictions[index])
+        end
+      end
+      
+      it 'should convert a single datum into one-member list' do 
+        result = subject.list('123')
+        expect(result).to be_kind_of(SkmList)
+        expect(result.members.first).to eq(123)
+      end      
+      
+      it 'should convert empty array into one-member list' do 
+        result = subject.vector([])
+        expect(result).to be_kind_of(SkmVector)
+        expect(result.members).to be_empty     
+      end
+    
+      
+      it 'should convert array of simple datums into vector' do
+        literals = simple_datum_tests.map { |(datum, _predicted)| datum }
+        predictions = simple_datum_tests.map { |(_datum, predicted)| predicted }
+        vector_result = subject.vector(literals)
+        expect(vector_result).to be_kind_of(SkmVector)
+        vector_result.members.each_with_index do |member, index|
+          expect(member).to eq(predictions[index])
+        end
+      end
+
+      it 'should convert a single datum into one-member vector' do 
+        result = subject.vector('123')
+        expect(result).to be_kind_of(SkmVector)
+        expect(result.members.first).to eq(123)
+      end      
+    end # context
+
+    context 'Arbitrary datums:' do
+      it 'should recognize & convert booleans' do
+        boolean_tests.each do |(literal, predicted)|
+          expect(subject.to_datum(literal)).to eq(predicted)
+        end
+      end
+      
+      it 'should recognize & convert integer literals' do
+        integer_tests.each do |(literal, predicted)|
+          expect(subject.to_datum(literal)).to eq(predicted)
+        end
+      end
+
+      it 'should recognize & convert real number literals' do
+        real_tests.each do |(literal, predicted)|
+          expect(subject.to_datum(literal)).to eq(predicted)
+        end
+      end
+
+      it 'should recognize & convert string literals' do
+        string_tests.each do |(literal, predicted)|
+          expect(subject.to_datum(literal)).to eq(predicted)
+        end
+      end
+
+      it 'should convert nested compound datums' do
+        literals = [
+          'false', '123', '-1.41', 
+          'foo', SkmVector.new(['uno', '2', 3.0]), 'bar'
+        ]
+        result = subject.list(literals)
+        expect(result).to be_kind_of(SkmList)
+        expect(result).to eq([false, 123, -1.41, 'foo', ['uno', 2, 3], 'bar'])
+      end
+    end
+
+  end # describe
+end # module

data/spec/skeem/element_visitor_spec.rb

@@ -0,0 +1,170 @@
+require_relative '../spec_helper'
+require_relative '../../lib/skeem/datum_dsl'
+
+# Load the class under test
+require_relative '../../lib/skeem/element_visitor'
+
+module Skeem
+  describe SkmElementVisitor do
+    include DatumDSL
+  let(:simple_datum) { integer 42 }
+  let(:listener) do
+    fake = double('fake-subscriber')
+    fake.define_singleton_method(:accept_all) {}
+    fake
+  end
+
+    # Default instantiation rule
+    subject { SkmElementVisitor.new(simple_datum) }
+
+    context 'Standard creation & initialization:' do
+      it 'should be initialized with a parse tree argument' do
+        expect { SkmElementVisitor.new(simple_datum) }.not_to raise_error
+      end
+
+      it 'should know the parse tree to visit' do
+        expect(subject.root).to eq(simple_datum)
+      end
+
+      it "shouldn't have subscribers at start" do
+        expect(subject.subscribers).to be_empty
+      end
+    end # context
+
+    context 'Subscribing:' do
+      let(:listener1) { double('fake-subscriber1') }
+      let(:listener2) { double('fake-subscriber2') }
+
+      it 'should allow subscriptions' do
+        subject.subscribe(listener1)
+        expect(subject.subscribers.size).to eq(1)
+        expect(subject.subscribers).to eq([listener1])
+
+        subject.subscribe(listener2)
+        expect(subject.subscribers.size).to eq(2)
+        expect(subject.subscribers).to eq([listener1, listener2])
+      end
+
+      it 'should allow un-subcriptions' do
+        subject.subscribe(listener1)
+        subject.subscribe(listener2)
+        subject.unsubscribe(listener2)
+        expect(subject.subscribers.size).to eq(1)
+        expect(subject.subscribers).to eq([listener1])
+        subject.unsubscribe(listener1)
+        expect(subject.subscribers).to be_empty
+      end
+    end # context
+
+    context 'Visiting simple datum:' do
+      let(:runtime) { double('fake-runtime') }
+
+      it 'should allow the visit of simple datum object' do
+        subject.subscribe(listener)
+        expect(listener).to receive(:before_simple_datum).with(runtime, simple_datum)
+        expect(listener).to receive(:after_simple_datum).with(runtime, simple_datum)
+        subject.start(runtime)
+        expect(subject.runtime).to eq(runtime)
+      end
+    end # context
+
+    context 'Visiting compound datum:' do
+      let(:runtime) { double('fake-runtime') }
+
+      it 'should allow the visit of a flat list' do
+        ls = list ['#false', 3, 'foo']
+        instance = SkmElementVisitor.new(ls)
+        instance.subscribe(listener)
+        expect(listener).to receive(:before_compound_datum).with(runtime, ls).ordered
+        expect(listener).to receive(:before_children).with(runtime, ls, ls.members).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, ls.members[0]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, ls.members[0]).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, ls.members[1]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, ls.members[1]).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, ls.members[2]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, ls.members[2]).ordered
+        expect(listener).to receive(:after_children).with(runtime, ls, ls.members).ordered
+        expect(listener).to receive(:after_compound_datum).with(runtime, ls).ordered
+        instance.start(runtime)
+      end
+
+      it 'should allow the visit of a flat vector' do
+        vec = vector ['#false', 3, 'foo']
+        instance = SkmElementVisitor.new(vec)
+        instance.subscribe(listener)
+        expect(listener).to receive(:before_compound_datum).with(runtime, vec).ordered
+        expect(listener).to receive(:before_children).with(runtime, vec, vec.members).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[0]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[0]).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[1]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[1]).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[2]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[2]).ordered
+        expect(listener).to receive(:after_children).with(runtime, vec, vec.members).ordered
+        expect(listener).to receive(:after_compound_datum).with(runtime, vec).ordered
+        instance.start(runtime)
+      end
+
+      it 'should allow the visit of a nested compound datum' do
+        nested_list = list ['uno', 'twei', 'three']
+        vec = vector ['#false', 3, nested_list, 'foo']
+        instance = SkmElementVisitor.new(vec)
+        instance.subscribe(listener)
+        expect(listener).to receive(:before_compound_datum).with(runtime, vec).ordered
+        expect(listener).to receive(:before_children).with(runtime, vec, vec.members).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[0]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[0]).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[1]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[1]).ordered
+        expect(listener).to receive(:before_compound_datum).with(runtime, vec.members[2]).ordered
+        expect(listener).to receive(:before_children).with(runtime, nested_list, nested_list.members).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.members[0]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.members[0]).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.members[1]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.members[1]).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.members[2]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.members[2]).ordered
+        expect(listener).to receive(:after_children).with(runtime, nested_list, nested_list.members).ordered
+        expect(listener).to receive(:after_compound_datum).with(runtime, nested_list).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[3]).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[3]).ordered
+        expect(listener).to receive(:after_children).with(runtime, vec, vec.members).ordered
+        expect(listener).to receive(:after_compound_datum).with(runtime, vec).ordered
+        instance.start(runtime)
+      end
+
+      # it 'should allow the visit of list datum object' do
+        # subject.subscribe(listener)
+        # expect(listener).to receive(:before_compound_datum).with(runtime, simple_datum)
+        # expect(listener).to receive(:after_compound_datum).with(runtime, simple_datum)
+        # subject.start(runtime)
+        # expect(subject.runtime).to eq(runtime)
+      # end
+    end # context
+
+=begin
+      it 'should react to the start_visit_nonterminal message' do
+        # Notify subscribers when start the visit of a non-terminal node
+        expect(listener1).to receive(:before_non_terminal).with(nterm_node)
+        subject.visit_nonterminal(nterm_node)
+      end
+
+      it 'should react to the visit_children message' do
+        # Notify subscribers when start the visit of children nodes
+        children = nterm_node.subnodes
+        args = [nterm_node, children]
+        expect(listener1).to receive(:before_subnodes).with(*args)
+        expect(listener1).to receive(:before_terminal).with(children[0])
+        expect(listener1).to receive(:after_terminal).with(children[0])
+        expect(listener1).to receive(:after_subnodes).with(nterm_node, children)
+        subject.send(:traverse_subnodes, nterm_node)
+      end
+
+      it 'should react to the end_visit_nonterminal message' do
+        # Notify subscribers when ending the visit of a non-terminal node
+        expect(listener1).to receive(:after_non_terminal).with(nterm_node)
+        subject.end_visit_nonterminal(nterm_node)
+      end
+=end
+  end # describe
+end # module