loxxy 0.0.21 → 0.0.26

data/spec/back_end/engine_spec.rb

@@ -34,6 +34,7 @@ module Loxxy
         let(:var_decl) { Ast::LoxVarStmt.new(sample_pos, 'greeting', greeting) }
         let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
 
+
         it "should react to 'after_var_stmt' event" do
           expect { subject.after_var_stmt(var_decl) }.not_to raise_error
           current_env = subject.symbol_table.current_env

data/spec/back_end/environment_spec.rb

@@ -9,7 +9,7 @@ module Loxxy
   module BackEnd
     describe Environment do
       let(:foo) { Datatype::LXString.new('foo') }
-      let(:bar) { Datatype::LXString.new('bar') }      
+      let(:bar) { Datatype::LXString.new('bar') }
       let(:mother) { Environment.new }
       subject { Environment.new(mother) }
 
@@ -32,7 +32,7 @@ module Loxxy
         end
 
         it 'should know its parent (if any)' do
-          expect(subject.parent).to eq(mother)
+          expect(subject.enclosing).to eq(mother)
         end
       end # context
 

data/spec/back_end/symbol_table_spec.rb

@@ -46,8 +46,8 @@ module Loxxy
         end
 
         it 'should allow the addition of several labels for same env' do
-          i_name = subject.insert(var('q'))
-          #expect(i_name).to match(/^q_[0-9a-z]*$/)
+          subject.insert(var('q'))
+          # expect(i_name).to match(/^q_[0-9a-z]*$/)
 
           expect { subject.insert(var('x')) }.not_to raise_error
           expect(subject.name2envs['x']).to be_kind_of(Array)
@@ -60,7 +60,7 @@ module Loxxy
           new_env = BackEnd::Environment.new
           expect { subject.enter_environment(new_env) }.not_to raise_error
           expect(subject.current_env).to eq(new_env)
-          expect(subject.current_env.parent).to eq(subject.root)
+          expect(subject.current_env.enclosing).to eq(subject.root)
           expect(subject.name2envs['q']).to eq([subject.root])
         end
 

data/spec/back_end/variable_spec.rb

@@ -17,10 +17,10 @@ module Loxxy
         it 'should be initialized with a name and a value, or...' do
           expect { Variable.new(sample_name, sample_value) }.not_to raise_error
         end
-        
+
         it 'should be initialized with just a name' do
           expect { Variable.new(sample_name) }.not_to raise_error
-        end        
+        end
 
         it 'should know its name' do
           expect(subject.name).to eq(sample_name)
@@ -29,11 +29,11 @@ module Loxxy
         it 'should have a frozen name' do
           expect(subject.name).to be_frozen
         end
-        
+
         it 'should know its value (if provided)' do
           expect(subject.value).to eq(sample_value)
         end
-        
+
         it 'should have a nil value otherwise' do
           instance = Variable.new(sample_name)
           expect(instance.value).to eq(Datatype::Nil.instance)

data/spec/front_end/parser_spec.rb

@@ -64,7 +64,8 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::False.instance)
         end
@@ -72,7 +73,8 @@ module Loxxy
         it 'should parse a true literal' do
           input = 'true;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::True.instance)
         end
@@ -81,7 +83,7 @@ module Loxxy
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root
+            leaf = ptree.root.subnodes[0]
             expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
             expect(leaf.literal).to be_kind_of(Datatype::Number)
             expect(leaf.literal.value).to eq(source.to_f)
@@ -96,7 +98,7 @@ module Loxxy
           ]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root
+            leaf = ptree.root.subnodes[0]
             expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
             expect(leaf.literal).to be_kind_of(Datatype::LXString)
             expect(leaf.literal.value).to eq(source.gsub(/(^")|(";$)/, ''))
@@ -106,7 +108,7 @@ module Loxxy
         it 'should parse a nil literal' do
           input = 'nil;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -119,7 +121,7 @@ module Loxxy
             print "Hello, world!";
 LOX_END
           ptree = subject.parse(program)
-          prnt_stmt = ptree.root
+          prnt_stmt = ptree.root.subnodes[0]
           expect(prnt_stmt).to be_kind_of(Ast::LoxPrintStmt)
           expect(prnt_stmt.subnodes[0]).to be_kind_of(Ast::LoxLiteralExpr)
           expect(prnt_stmt.subnodes[0].literal).to be_kind_of(Loxxy::Datatype::LXString)
@@ -131,7 +133,7 @@ LOX_END
         it 'should parse the addition of two number literals' do
           input = '123 + 456;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(123)
@@ -141,7 +143,7 @@ LOX_END
         it 'should parse the subtraction of two number literals' do
           input = '4 - 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0].literal.value).to eq(4)
@@ -151,7 +153,7 @@ LOX_END
         it 'should parse multiple additive operations' do
           input = '5 + 2 - 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -164,7 +166,7 @@ LOX_END
         it 'should parse the division of two number literals' do
           input = '8 / 2;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0].literal.value).to eq(8)
@@ -174,7 +176,7 @@ LOX_END
         it 'should parse the product of two number literals' do
           input = '12.34 * 0.3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:*)
           expect(expr.operands[0].literal.value).to eq(12.34)
@@ -184,7 +186,7 @@ LOX_END
         it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -197,7 +199,7 @@ LOX_END
         it 'should parse combination of terms and factors' do
           input = '5 + 2 / 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(5)
@@ -212,7 +214,7 @@ LOX_END
         it 'should parse the concatenation of two string literals' do
           input = '"Lo" + "ve";'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq('Lo')
@@ -225,7 +227,7 @@ LOX_END
         %w[> >= < <=].each do |predicate|
           input = "3 #{predicate} 2;"
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(predicate.to_sym)
           expect(expr.operands[0].literal.value).to eq(3)
@@ -239,7 +241,7 @@ LOX_END
           %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
-            expr = ptree.root
+            expr = ptree.root.subnodes[0]
             expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
             expect(expr.operator).to eq(predicate.to_sym)
             expect(expr.operands[0].literal.value).to eq(3)
@@ -250,7 +252,7 @@ LOX_END
         it 'should parse combination of equality expressions' do
           input = '5 != 2 == false; // A bit contrived example'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:==)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -266,7 +268,7 @@ LOX_END
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
-            expr = ptree.root
+            expr = ptree.root.subnodes[0]
             expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
             expect(expr.operator).to eq(connector.to_sym)
             expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -283,7 +285,7 @@ LOX_END
         it 'should parse a combinations of logical expressions' do
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operator).to eq(:or) # or has lower precedence than and
           expect(expr.operands[0]).to be_kind_of(Ast::LoxLogicalExpr)

data/spec/interpreter_spec.rb

@@ -52,7 +52,14 @@ module Loxxy
     end # context
 
     context 'Evaluating Lox code:' do
-      let(:hello_world) { 'print "Hello, world!";' }
+      let(:hello_world) do
+        lox = <<-LOX_END
+        var greeting = "Hello"; // Declaring a variable
+        print greeting + ", " + "world!"; // ... Playing with concatenation
+LOX_END
+
+        lox
+      end
 
       it 'should evaluate core data types' do
         result = subject.evaluate('true; // Not false')
@@ -235,7 +242,7 @@ module Loxxy
           ['if (true) print "then-branch"; else print "else-branch";', 'then-branch'],
           ['if (false) print "then-branch"; else print "else-branch";', 'else-branch'],
           ['if (0) print "then-branch"; else print "else-branch";', 'then-branch'],
-          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch'],
+          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch']
           # TODO: test with else block body
 
           # TODO: A dangling else binds to the right-most if.
@@ -245,7 +252,7 @@ module Loxxy
           io = StringIO.new
           cfg = { ostream: io }
           lox = Loxxy::Interpreter.new(cfg)
-          result = lox.evaluate(source)
+          lox.evaluate(source)
           expect(io.string).to eq(predicted)
         end
       end
@@ -259,6 +266,98 @@ module Loxxy
         expect { subject.evaluate('var iAmNil;') }.not_to raise_error
       end
 
+      it 'should accept variable mention' do
+        program = <<-LOX_END
+        var foo = "bar";
+        print foo; // => bar
+LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('bar')
+      end
+
+      it 'should set uninitialized variables to nil' do
+        program = <<-LOX_END
+        var a;
+        print a; // => nil
+LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('nil')
+      end
+
+      it 'should accept assignments to a global variable' do
+        program = <<-LOX_END
+          var a = "before";
+          print a; // output: before
+
+          a = "after";
+          print a; // output: after
+
+          print a = "arg"; // output: arg
+          print a; // output: arg
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('beforeafterargarg')
+      end
+
+      it 'should support variables local to a block' do
+        program = <<-LOX_END
+        {
+          var a = "first";
+          print a;
+        }
+        {
+          var a = "second";
+          print a;
+        }
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('firstsecond')
+      end
+
+      it 'should support the shadowing of variables in a block' do
+        program = <<-LOX_END
+        var a = "outer";
+
+        {
+          var a = "inner";
+          print a; // output: inner
+        }
+
+        print a; // output: outer
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('innerouter')
+      end
+
+      it 'should implement single statement while loops' do
+        program = <<-LOX_END
+          // Single-expression body.
+          var c = 0;
+          while (c < 3) print c = c + 1;
+          // output: 1
+          // output: 2
+          // output: 3
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('123')
+      end
+
+      it 'should implement block body while loops' do
+        program = <<-LOX_END
+          // Block body.
+          var a = 0;
+          while (a < 3) {
+            print a;
+            a = a + 1;
+          }
+          // output: 0
+          // output: 1
+          // output: 2
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('012')
+      end
+
       it 'should print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.26
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-16 00:00:00.000000000 Z
+date: 2021-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -87,7 +87,9 @@ files:
 - lib/loxxy/ast/all_lox_nodes.rb
 - lib/loxxy/ast/ast_builder.rb
 - lib/loxxy/ast/ast_visitor.rb
+- lib/loxxy/ast/lox_assign_expr.rb
 - lib/loxxy/ast/lox_binary_expr.rb
+- lib/loxxy/ast/lox_block_stmt.rb
 - lib/loxxy/ast/lox_compound_expr.rb
 - lib/loxxy/ast/lox_grouping_expr.rb
 - lib/loxxy/ast/lox_if_stmt.rb
@@ -96,8 +98,11 @@ files:
 - lib/loxxy/ast/lox_node.rb
 - lib/loxxy/ast/lox_noop_expr.rb
 - lib/loxxy/ast/lox_print_stmt.rb
+- lib/loxxy/ast/lox_seq_decl.rb
 - lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/ast/lox_var_stmt.rb
+- lib/loxxy/ast/lox_variable_expr.rb
+- lib/loxxy/ast/lox_while_stmt.rb
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/back_end/entry.rb
 - lib/loxxy/back_end/environment.rb