loxxy 0.0.17 → 0.0.22

data/spec/back_end/variable_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/variable'
+
+
+module Loxxy
+  module BackEnd
+    describe Variable do
+      let(:sample_name) { 'iAmAVariable' }
+      let(:sample_value) { 'here is my value' }
+      subject { Variable.new(sample_name, sample_value) }
+
+      context 'Initialization:' do
+        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        
+
+        it 'should know its name' do
+          expect(subject.name).to eq(sample_name)
+        end
+
+        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)
+        end
+
+        # it 'should know its default internal name' do
+          # # By default: internal name == label
+          # expect(subject.i_name).to eq(subject.label)
+        # end
+
+        # it 'should have a nil suffix' do
+          # expect(subject.suffix).to be_nil
+        # end
+      end # context
+
+      context 'Provided service:' do
+        let(:sample_suffix) { 'sample-suffix' }
+        it 'should have a label equal to its user-defined name' do
+          # expect(subject.label).to eq(subject.name)
+        end
+
+        it 'should accept a suffix' do
+          # expect { subject.suffix = sample_suffix }.not_to raise_error
+          # expect(subject.suffix).to eq(sample_suffix)
+        end
+
+        it 'should calculate its internal name' do
+          # # Rule: empty suffix => internal name == label
+          # subject.suffix = ''
+          # expect(subject.i_name).to eq(subject.label)
+
+          # # Rule: suffix starting underscore: internal name = label + suffix
+          # subject.suffix = '_10'
+          # expect(subject.i_name).to eq(subject.label + subject.suffix)
+
+          # # Rule: ... otherwise: internal name == suffix
+          # subject.suffix = sample_suffix
+          # expect(subject.i_name).to eq(subject.suffix)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

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)
@@ -262,12 +264,12 @@ LOX_END
       end # context
 
       context 'Parsing logical expressions' do
-        it 'should parse the logical operations betweentwo sub-expression' do
+        it 'should parse the logical operations between two sub-expression' do
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
-            expr = ptree.root
-            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            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)
             expect(expr.operands[0].operator).to eq(:>)
@@ -283,10 +285,10 @@ 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
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          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::LoxBinaryExpr)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operands[0].operator).to eq(:and)
           conjuncts = expr.operands[0].operands
           expect(conjuncts[0]).to be_kind_of(Ast::LoxBinaryExpr)

data/spec/interpreter_spec.rb

@@ -52,7 +52,12 @@ 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
+      end
 
       it 'should evaluate core data types' do
         result = subject.evaluate('true; // Not false')
@@ -164,6 +169,110 @@ module Loxxy
         end
       end
 
+      it 'should evaluate the "conjunction" of two values' do
+        [
+          # Return the first falsey argument
+          ['false and 1;', false],
+          ['nil and 1;', nil],
+          ['true and 1;', 1],
+          ['1 and 2 and false;', false],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are truthy
+          ['1 and true;', true],
+          ['0 and true;', true],
+          ['"false" and 0;', 0],
+          ['1 and 2 and 3;', 3]
+
+          # TODO test short-circuit at first false argument
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the "disjunction" of two values' do
+        [
+          # Return the first truthy argument
+          ['1 or true;', 1],
+          ['false or 1;', 1],
+          ['nil or 1;', 1],
+          ['false or false or true;', true],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are falsey
+          ['false or false;', false],
+          ['nil or false;', false],
+          ['false or nil;', nil],
+          ['false or false or false;', false],
+          ['false or false or nil;', nil]
+
+          # TODO test short-circuit at first false argument
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should support expressions between parentheses' do
+        [
+          ['3 + 4 * 5;', 23],
+          ['(3 + 4) * 5;', 35],
+          ['(5 - (3 - 1)) + -(1);', 2]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate an if statement' do
+        [
+          # Evaluate the 'then' expression if the condition is true.
+          ['if (true) print "then-branch";', 'then-branch'],
+          ['if (false) print "ignored";', ''],
+          # TODO: test with then block body
+          # TODO: test with assignment in if condition
+
+          # Evaluate the 'else' expression if the condition is false.
+          ['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'],
+          # TODO: test with else block body
+
+          # TODO: A dangling else binds to the right-most if.
+          # ['if (true) if (false) print "bad"; else print "good";', 'good'],
+          # ['if (false) if (true) print "bad"; else print "worse";', 'bad']
+        ].each do |(source, predicted)|
+          io = StringIO.new
+          cfg = { ostream: io }
+          lox = Loxxy::Interpreter.new(cfg)
+          result = lox.evaluate(source)
+          expect(io.string).to eq(predicted)
+        end
+      end
+
+      it 'should accept variable declarations' do
+        # Variable with initialization value
+        var_decl = 'var iAmAVariable = "here is my value";'
+        expect { subject.evaluate(var_decl) }.not_to raise_error
+
+        # Variable without initialization value
+        expect { subject.evaluate('var iAmNil;') }.not_to raise_error
+      end
+
+      it 'should accept variable mention' do
+        program = <<-LOX_END
+        var foo = "bar";
+        print foo;
+LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('bar')
+      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.17
+  version: 0.0.22
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-12 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -89,12 +89,22 @@ files:
 - lib/loxxy/ast/ast_visitor.rb
 - lib/loxxy/ast/lox_binary_expr.rb
 - lib/loxxy/ast/lox_compound_expr.rb
+- lib/loxxy/ast/lox_grouping_expr.rb
+- lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
+- lib/loxxy/ast/lox_logical_expr.rb
 - 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/back_end/engine.rb
+- lib/loxxy/back_end/entry.rb
+- lib/loxxy/back_end/environment.rb
+- lib/loxxy/back_end/symbol_table.rb
+- lib/loxxy/back_end/variable.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb
 - lib/loxxy/datatype/builtin_datatype.rb
@@ -112,6 +122,9 @@ files:
 - lib/loxxy/version.rb
 - loxxy.gemspec
 - spec/back_end/engine_spec.rb
+- spec/back_end/environment_spec.rb
+- spec/back_end/symbol_table_spec.rb
+- spec/back_end/variable_spec.rb
 - spec/datatype/boolean_spec.rb
 - spec/datatype/lx_string_spec.rb
 - spec/datatype/nil_spec.rb
@@ -148,6 +161,9 @@ specification_version: 4
 summary: An implementation of the Lox programming language. WIP
 test_files:
 - spec/back_end/engine_spec.rb
+- spec/back_end/environment_spec.rb
+- spec/back_end/symbol_table_spec.rb
+- spec/back_end/variable_spec.rb
 - spec/datatype/boolean_spec.rb
 - spec/datatype/lx_string_spec.rb
 - spec/datatype/nil_spec.rb