loxxy 0.0.16 → 0.0.21

data/lib/loxxy/interpreter.rb

@@ -31,7 +31,7 @@ module Loxxy
       ast_tree = parser.parse(lox_input)
       visitor = Ast::ASTVisitor.new(ast_tree)
 
-      # Back-end launches the tree walking & reponds to visit events
+      # Back-end launches the tree walking & responds to visit events
       # by executing the code determined by the visited AST node.
       engine = BackEnd::Engine.new(config)
       engine.execute(visitor)

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.0.16'
+  VERSION = '0.0.21'
 end

data/spec/back_end/engine_spec.rb

@@ -31,8 +31,16 @@ module Loxxy
       context 'Listening to visitor events:' do
         let(:greeting) { Datatype::LXString.new('Hello, world') }
         let(:sample_pos) { double('fake-position') }
+        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
+          expect(current_env.defns['greeting']).to be_kind_of(Variable)
+          expect(current_env.defns['greeting'].value).to eq(greeting)
+        end
+
         it "should react to 'before_literal_expr' event" do
           expect { subject.before_literal_expr(lit_expr) }.not_to raise_error
           expect(subject.stack.pop).to eq(greeting)

data/spec/back_end/environment_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/environment'
+
+module Loxxy
+  module BackEnd
+    describe Environment do
+      let(:foo) { Datatype::LXString.new('foo') }
+      let(:bar) { Datatype::LXString.new('bar') }      
+      let(:mother) { Environment.new }
+      subject { Environment.new(mother) }
+
+      # Shortand factory method.
+      def var(aName, aValue)
+        Variable.new(aName, aValue)
+      end
+
+      context 'Initialization:' do
+        it 'could be initialized without argument' do
+          expect { Environment.new }.not_to raise_error
+        end
+
+        it 'could be initialized with a parent environment' do
+          expect { Environment.new(mother) }.not_to raise_error
+        end
+
+        it "shouldn't have definitions by default" do
+          expect(subject.defns).to be_empty
+        end
+
+        it 'should know its parent (if any)' do
+          expect(subject.parent).to eq(mother)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of a variable' do
+          subject.insert(var('a', foo))
+          expect(subject.defns).not_to be_empty
+          var_a = subject.defns['a']
+          expect(var_a).to be_kind_of(Variable)
+          expect(var_a.name).to eq('a')
+        end
+
+        it 'should accept the addition of multiple variables' do
+          subject.insert(var('a', foo))
+          expect(subject.defns).not_to be_empty
+
+          subject.insert(var('b', bar))
+          var_b = subject.defns['b']
+          expect(var_b).to be_kind_of(Variable)
+          expect(var_b.name).to eq('b')
+        end
+
+        # it 'should set the suffix of just created variable' do
+          # subject.insert(var('a'))
+          # var_a = subject.defns['a']
+          # expect(var_a.suffix).to eq("_#{subject.object_id.to_s(16)}")
+        # end
+
+        # it 'should complain when variable names collide' do
+          # subject.insert(var('c'))
+          # expect(subject.defns['c']).to be_kind_of(Datatype::Variable)
+          # err = StandardError
+          # err_msg = "Variable with name 'c' already exists."
+          # expect { subject.insert(var('c')) }.to raise_error(err, err_msg)
+        # end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/back_end/symbol_table_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/loxxy/back_end/variable'
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/symbol_table'
+
+module Loxxy
+  module BackEnd
+    describe SymbolTable do
+      subject { SymbolTable.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { SymbolTable.new }.not_to raise_error
+        end
+
+        it 'should have a root BackEnd' do
+          expect(subject.root).not_to be_nil
+          expect(subject.current_env).to eq(subject.root)
+          expect(subject.root).to be_kind_of(BackEnd::Environment)
+        end
+
+        it "shouldn't have names at initialization" do
+          expect(subject.name2envs).to be_empty
+        end
+
+        it 'should be empty at initialization' do
+          expect(subject).to be_empty
+        end
+      end # context
+
+      context 'Provided services:' do
+        def var(aName)
+          Variable.new(aName)
+        end
+
+        it 'should allow the addition of a variable' do
+          expect { subject.insert(var('q')) }.not_to raise_error
+          expect(subject).not_to be_empty
+          expect(subject.name2envs['q']).to be_kind_of(Array)
+          expect(subject.name2envs['q'].size).to eq(1)
+          expect(subject.name2envs['q'].first).to eq(subject.current_env)
+          expect(subject.current_env.defns['q']).to be_kind_of(BackEnd::Variable)
+        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]*$/)
+
+          expect { subject.insert(var('x')) }.not_to raise_error
+          expect(subject.name2envs['x']).to be_kind_of(Array)
+          expect(subject.name2envs['x'].first).to eq(subject.current_env)
+          expect(subject.current_env.defns['x']).to be_kind_of(BackEnd::Variable)
+        end
+
+        it 'should allow the entry into a new scope' do
+          subject.insert(var('q'))
+          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.name2envs['q']).to eq([subject.root])
+        end
+
+        it 'should allow the addition of same name in different scopes' do
+          subject.insert(var('q'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('q'))
+          expect(subject.name2envs['q']).to be_kind_of(Array)
+          expect(subject.name2envs['q'].size).to eq(2)
+          expect(subject.name2envs['q'].first).to eq(subject.root)
+          expect(subject.name2envs['q'].last).to eq(subject.current_env)
+          expect(subject.current_env.defns['q']).to be_kind_of(BackEnd::Variable)
+        end
+
+        it 'should allow the removal of a scope' do
+          subject.insert(var('q'))
+          new_env = BackEnd::Environment.new
+          subject.enter_environment(new_env)
+          subject.insert(var('q'))
+          expect(subject.name2envs['q'].size).to eq(2)
+
+          expect { subject.leave_environment }.not_to raise_error
+          expect(subject.current_env).to eq(subject.root)
+          expect(subject.name2envs['q'].size).to eq(1)
+          expect(subject.name2envs['q']).to eq([subject.root])
+        end
+
+        it 'should allow the search of an entry based on its name' do
+          subject.insert(var('q'))
+          subject.insert(var('x'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('q'))
+          subject.insert(var('y'))
+
+          # Search for unknown name
+          expect(subject.lookup('z')).to be_nil
+
+          # Search for existing unique names
+          expect(subject.lookup('y')).to eq(subject.current_env.defns['y'])
+          expect(subject.lookup('x')).to eq(subject.root.defns['x'])
+
+          # Search for redefined name
+          expect(subject.lookup('q')).to eq(subject.current_env.defns['q'])
+        end
+
+        # it 'should allow the search of an entry based on its i_name' do
+          # subject.insert(var('q'))
+          # i_name_x = subject.insert(var('x'))
+          # subject.enter_environment(BackEnd::Environment.new)
+          # i_name_q2 = subject.insert(var('q'))
+          # i_name_y = subject.insert(var('y'))
+
+          # # Search for unknown i_name
+          # expect(subject.lookup_i_name('dummy')).to be_nil
+
+          # curr_scope = subject.current_env
+          # # # Search for existing unique names
+          # expect(subject.lookup_i_name(i_name_y)).to eq(curr_scope.defns['y'])
+          # expect(subject.lookup_i_name(i_name_x)).to eq(subject.root.defns['x'])
+
+          # # Search for redefined name
+          # expect(subject.lookup_i_name(i_name_q2)).to eq(curr_scope.defns['q'])
+        # end
+
+        it 'should list all the variables defined in all the szcope chain' do
+          subject.insert(var('q'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('x'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('y'))
+          subject.insert(var('x'))
+
+          vars = subject.all_variables
+          expect(vars.map(&:name)).to eq(%w[q x y x])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

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

@@ -262,12 +262,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)
+            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(:>)
@@ -284,9 +284,9 @@ LOX_END
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
           ptree = subject.parse(input)
           expr = ptree.root
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          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

@@ -107,6 +107,158 @@ module Loxxy
         end
       end
 
+      it 'should evaluate a comparison of two numbers' do
+        [
+          ['1 < 2;', true],
+          ['2 < 2;', false],
+          ['2 < 1;', false],
+          ['1 <= 2;', true],
+          ['2 <= 2;', true],
+          ['2 <= 1;', false],
+          ['1 > 2;', false],
+          ['2 > 2;', false],
+          ['2 > 1;', true],
+          ['1 >= 2;', false],
+          ['2 >= 2;', true],
+          ['2 >= 1;', true],
+          ['0 < -0;', false],
+          ['-0 < 0;', false],
+          ['0 > -0;', false],
+          ['-0 > 0;', false],
+          ['0 <= -0;', true],
+          ['-0 <= 0;', true],
+          ['0 >= -0;', true],
+          ['-0 >= 0;', true]
+        ].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 change sign of a number' do
+        [
+          ['- 3;', -3],
+          ['- - 3;', 3],
+          ['- - - 3;', -3]
+        ].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 negation of an object' do
+        [
+          ['!true;', false],
+          ['!false;', true],
+          ['!!true;', true],
+          ['!123;', false],
+          ['!0;', false],
+          ['!nil;', true],
+          ['!"";', false]
+        ].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 "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 print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')