skeem 0.0.23 → 0.0.24

data/spec/skeem/skm_simple_datum_spec.rb

@@ -0,0 +1,233 @@
+require 'ostruct'
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/skm_simple_datum' # Load the classes under test
+
+module Skeem
+  describe SkmSimpleDatum 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
+    let(:instance) { SkmSimpleDatum.create(3) }
+    subject { SkmSimpleDatum.new(dummy_token, pos) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a token and a position' do
+        expect { SkmSimpleDatum.new(dummy_token, pos) }.not_to raise_error
+      end
+
+      it 'could be created with just a value' do
+        expect { SkmSimpleDatum.create(3) }.not_to raise_error
+        expect(instance).to be_kind_of(SkmSimpleDatum)
+        expect(instance.value).to eq(3)
+      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
+
+    context 'Provided services:' do
+      let(:runtime) { double('fake-runtime') }
+
+      it 'should assert that it is equal to itself' do
+        expect(subject).to eq(subject)
+      end
+
+     it 'should assert the equality by value' do
+        # Comparison with other instances
+        expect(instance).to eq(SkmSimpleDatum.create(3))
+        expect(instance).not_to eq(SkmSimpleDatum.create('foo'))
+
+        # Comparison with PORO values
+        expect(instance).to eq(3)
+        expect(instance).not_to eq('foo')
+      end
+
+      it 'should be self-evaluating' do
+        expect(subject.evaluate(runtime)).to be_equal(subject)
+      end
+
+      it 'should be self-quasiquoting' do
+        expect(subject.quasiquote(runtime)).to be_equal(subject)
+      end
+
+      it 'should return its text representation' do
+        expect(subject.inspect).to eq("<Skeem::SkmSimpleDatum: sample-value>")
+      end
+
+      it 'should respond to visitor' do
+        visitor = double('fake-visitor')
+        expect(visitor).to receive(:visit_simple_datum).with(subject)
+        expect { subject.accept(visitor) }.not_to raise_error
+      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
+
+    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
+
+    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 # context
+  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 # context
+  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 # context
+  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
+end # module

data/spec/skeem/skm_unary_expression_spec.rb

@@ -0,0 +1,201 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/datum_dsl'
+require_relative '../../lib/skeem/environment'
+require_relative '../../lib/skeem/skm_unary_expression' # Load the classes under test
+
+module Skeem
+  describe SkmUnaryExpression do
+    let(:pos) { double('fake-position') }
+    let(:sample_child) { double('fake-child') }
+
+    subject { SkmUnaryExpression.new(pos, sample_child) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a position and a child element' do
+        expect{ SkmUnaryExpression.new(pos, sample_child) }.not_to raise_error
+      end
+
+      it 'should know its child' do
+        expect(subject.child).to eq(sample_child)
+      end
+    end # context
+
+    context 'Provided basic services:' do
+      it 'should respond to visitor' do
+        visitor = double('fake-visitor')
+        expect(visitor).to receive(:visit_unary_expression).with(subject)
+        expect { subject.accept(visitor) }.not_to raise_error
+      end
+    end # context
+  end # describe
+
+  describe SkmQuotation do
+    include DatumDSL
+
+    let(:sample_literal) { string('foo') }
+
+    subject { SkmQuotation.new(sample_literal) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a Skeem element' do
+        expect{ SkmQuotation.new(sample_literal) }.not_to raise_error
+      end
+
+      it 'should know its datum' do
+        expect(subject.datum).to be_equal(sample_literal)
+        expect(subject.datum).to be_equal(subject.child)
+      end
+    end # context
+
+    context 'Provided services:' do
+      let(:runtime) { Runtime.new(Environment.new) }
+
+      # it 'should return the child(datum) at evaluation' do
+        # expect(subject.evaluate(runtime)).to be_equal(subject.child)
+      # end
+
+      it 'should implement quasiquotation' do
+        # Case 1: child is idempotent with quasiquote
+        expect(subject.quasiquote(runtime)).to be_equal(subject)
+
+        # Case 2: quasiquoted child is different
+        child = double('fake-child')
+        expect(child).to receive(:quasiquote).with(runtime).and_return(integer(3))
+        instance = SkmQuasiquotation.new(child)
+        expect(instance.child).to eq(child)
+        quasi_result = instance.quasiquote(runtime)
+        expect(quasi_result).to eq(3)
+      end
+
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmQuotation: <Skeem::SkmString: foo>>'
+        expect(subject.inspect).to eq(txt1)
+      end
+    end # context
+  end # describe
+
+
+  describe SkmQuasiquotation do
+    include DatumDSL
+
+    let(:sample_literal) { string('foo') }
+
+    subject { SkmQuasiquotation.new(sample_literal) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a Skeem element' do
+        expect{ SkmQuasiquotation.new(sample_literal) }.not_to raise_error
+      end
+    end # context
+
+    context 'Provided services:' do
+      let(:runtime) { Runtime.new(Environment.new) }
+
+      it 'should return the child(template) at evaluation' do
+        expect(subject.evaluate(runtime)).to be_equal(subject.child)
+      end
+
+      it 'should accept quasiquotation' do
+        # Case 1: child is idempotent with quasiquote
+        expect(subject.quasiquote(runtime)).to be_equal(subject.child)
+
+        # Case 2: quasiquoted child is different
+        child = double('fake-child')
+        expect(child).to receive(:quasiquote).with(runtime).and_return(integer(3))
+        instance = SkmQuotation.new(child)
+        expect(instance.child).to eq(child)
+        quasi_result = instance.quasiquote(runtime)
+        expect(quasi_result.child).to eq(3)
+      end
+
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmQuasiquotation: <Skeem::SkmString: foo>>'
+        expect(subject.inspect).to eq(txt1)
+      end
+    end # context
+  end # describe
+
+
+ describe SkmUnquotation do
+    include DatumDSL
+
+    let(:sample_literal) { string('foo') }
+
+    subject { SkmUnquotation.new(sample_literal) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a Skeem element' do
+        expect{ SkmUnquotation.new(sample_literal) }.not_to raise_error
+      end
+    end # context
+
+    context 'Provided services:' do
+      let(:runtime) { Runtime.new(Environment.new) }
+
+      it 'should return the child(template) at evaluation' do
+        expect(subject.evaluate(runtime)).to be_equal(subject.child)
+      end
+
+      it 'should accept quasiquotation' do
+        # Case 1: child is idempotent with evaluate
+        expect(subject.quasiquote(runtime)).to be_equal(subject.child)
+
+        # Case 2: quasiquoted child is different
+        child = double('fake-child')
+        expect(child).to receive(:evaluate).with(runtime).and_return(integer(3))
+        instance = SkmUnquotation.new(child)
+        expect(instance.child).to eq(child)
+        quasi_result = instance.quasiquote(runtime)
+        expect(quasi_result).to eq(3)
+      end
+
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmUnquotation: <Skeem::SkmString: foo>>'
+        expect(subject.inspect).to eq(txt1)
+      end
+    end # context
+  end # describe
+  
+  describe SkmVariableReference do
+    include DatumDSL
+
+    let(:pos) { double('fake-position') }
+    let(:sample_var) { identifier('three') }
+
+    subject { SkmVariableReference.new(pos, sample_var) }
+
+    context 'Initialization:' do
+      it 'should be initialized with a position and a symbol' do
+        expect{ SkmVariableReference.new(pos, sample_var) }.not_to raise_error
+      end
+
+      it 'should know its variable' do
+        expect(subject.variable).to be_equal(sample_var)
+        expect(subject.variable).to be_equal(subject.child)
+      end
+    end # context
+
+    context 'Provided services:' do
+      let(:dummy_def) { double('fake-definition') }
+      let(:runtime) { Runtime.new(Environment.new) }
+
+      before(:each) do
+        runtime.define('three', dummy_def)
+      end
+
+      it "should return the variable's value at evaluation" do
+        expect(dummy_def).to receive(:expression).and_return(integer(3))
+        expect(subject.evaluate(runtime)).to eq(3)
+      end
+
+      it "should return itself at quasiquotation" do
+        expect(subject.quasiquote(runtime)).to be_equal(subject)
+      end
+
+      it 'should return its text representation' do
+        txt1 = '<Skeem::SkmVariableReference: <Skeem::SkmIdentifier: three>>'
+        expect(subject.inspect).to eq(txt1)
+      end
+    end # context
+  end # describe
+end # module

data/spec/skeem/tokenizer_spec.rb

@@ -30,11 +30,14 @@ module Skeem
 
     context 'Delimiter and separator token recognition:' do
       it 'should tokenize single char delimiters' do
-        subject.reinitialize("( ) ' `")
+        subject.reinitialize("( ) ' ` . , ,@")
         tokens = subject.tokens
         tokens.each { |token| expect(token).to be_kind_of(SToken) }
         terminals = tokens.map(&:terminal)
-        prediction = %w[LPAREN RPAREN APOSTROPHE BACKQUOTE]
+        prediction = %w[LPAREN RPAREN APOSTROPHE
+          GRAVE_ACCENT PERIOD
+          COMMA COMMA_AT_SIGN
+        ]
         expect(terminals).to eq(prediction)
       end
     end # context
@@ -195,38 +198,8 @@ module Skeem
         expect(token.lexeme).to eq('Second text')
       end
     end
-=begin
-    context 'Scanning Scheme sample code' do
-      it 'should read examples from lis.py page' do
-        # Shallow tokenizer testing
-        source = <<-SCHEME
-(if (> (val x) 0)
-    (fn (+ (aref A i) (* 3 i))
-        (quote (one two)))
-      end
-    end
-SCHEME
-        subject.reinitialize(source)
-        expect { subject.tokens }.not_to raise_error
-
-        source = "(define circle-area (lambda (r) (* pi (* r r))))"
-        subject.reinitialize(source)
-        expect { subject.tokens }.not_to raise_error
-
-        source = "(define fact (lambda (n) (if (<= n 1) 1 (* n (fact (- n 1))))))"
-        subject.reinitialize(source)
-        expect { subject.tokens }.not_to raise_error
-
-        source = <<-SCHEME
-define first car)
-define rest cdr)
-define count (lambda (item L) (if L (+ (equal? item (first L)) (count item (rest L))) 0)))
-count 0 (list 0 1 2 3 0 0))
-SCHEME
-        subject.reinitialize(source)
-        expect { subject.tokens }.not_to raise_error
-      end
 
+    context 'Scanning Scheme sample code' do
       it 'should produce a sequence of token objects' do
         # Deeper tokenizer testing
         source = "(define circle-area (lambda (r) (* pi (* r r))))"
@@ -236,7 +209,7 @@ SCHEME
           ['DEFINE', 'define'],
           ['IDENTIFIER', 'circle-area'],
           ['LPAREN', '('],
-          ['IDENTIFIER', 'lambda'],
+          ['LAMBDA', 'lambda'],
           ['LPAREN', '('],
           ['IDENTIFIER', 'r'],
           ['RPAREN', ')'],
@@ -255,6 +228,5 @@ SCHEME
         match_expectations(subject, predicted)
       end
     end # context
-=end
   end # describe
 end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.24
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-24 00:00:00.000000000 Z
+date: 2018-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -85,7 +85,8 @@ files:
 - Rakefile
 - appveyor.yml
 - lib/skeem.rb
-- lib/skeem/convertible.rb
+- lib/skeem/datum_dsl.rb
+- lib/skeem/element_visitor.rb
 - lib/skeem/environment.rb
 - lib/skeem/grammar.rb
 - lib/skeem/interpreter.rb
@@ -95,11 +96,18 @@ files:
 - lib/skeem/runtime.rb
 - lib/skeem/s_expr_builder.rb
 - lib/skeem/s_expr_nodes.rb
+- lib/skeem/skm_compound_datum.rb
+- lib/skeem/skm_element.rb
+- lib/skeem/skm_expression.rb
+- lib/skeem/skm_simple_datum.rb
+- lib/skeem/skm_unary_expression.rb
 - lib/skeem/standard/base.skm
 - lib/skeem/stoken.rb
 - lib/skeem/tokenizer.rb
 - lib/skeem/version.rb
 - skeem.gemspec
+- spec/skeem/datum_dsl_spec.rb
+- spec/skeem/element_visitor_spec.rb
 - spec/skeem/environment_spec.rb
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/parser_spec.rb
@@ -107,6 +115,10 @@ files:
 - spec/skeem/primitive/primitive_procedure_spec.rb
 - spec/skeem/runtime_spec.rb
 - spec/skeem/s_expr_nodes_spec.rb
+- spec/skeem/skm_compound_datum_spec.rb
+- spec/skeem/skm_element_spec.rb
+- spec/skeem/skm_simple_datum_spec.rb
+- spec/skeem/skm_unary_expression_spec.rb
 - spec/skeem/tokenizer_spec.rb
 - spec/skeem_spec.rb
 - spec/spec_helper.rb
@@ -137,12 +149,18 @@ specification_version: 4
 summary: Skeem is an interpreter of a subset of the Scheme programming language. Scheme
   is a descendent of the Lisp language.
 test_files:
+- spec/skeem/datum_dsl_spec.rb
+- spec/skeem/element_visitor_spec.rb
 - spec/skeem/environment_spec.rb
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/parser_spec.rb
 - spec/skeem/primitive/primitive_builder_spec.rb
 - spec/skeem/primitive/primitive_procedure_spec.rb
 - spec/skeem/runtime_spec.rb
+- spec/skeem/skm_compound_datum_spec.rb
+- spec/skeem/skm_element_spec.rb
+- spec/skeem/skm_simple_datum_spec.rb
+- spec/skeem/skm_unary_expression_spec.rb
 - spec/skeem/s_expr_nodes_spec.rb
 - spec/skeem/tokenizer_spec.rb
 - spec/skeem_spec.rb

data/lib/skeem/convertible.rb

@@ -1,23 +0,0 @@
-require_relative 's_expr_nodes'
-
-module Skeem
-  module Convertible
-    # Convert Ruby object into its Skeem counterpart
-    def to_skm(native_obj)
-      return native_obj if native_obj.kind_of?(SkmElement)
-
-      case native_obj
-        when TrueClass, FalseClass
-          SkmBoolean.create(native_obj)
-        when Float
-          SkmReal.create(native_obj)
-        when Integer
-          SkmInteger.create(native_obj)
-        when String
-          SkmString.create(native_obj)
-        else
-          raise StandardError, "No conversion of #{native_obj.class}"
-      end
-    end
-  end # module
-end # module