loxxy 0.0.7 → 0.0.12

data/lib/loxxy/ast/lox_compound_expr.rb

@@ -5,7 +5,7 @@ require_relative 'lox_node'
 module Loxxy
   module Ast
     class LoxCompoundExpr < LoxNode
-      # @return [Array<Ast::LoxNode>]
+      # @return [Array<Ast::LoxNode>] the children nodes (sub-expressions)
       attr_reader :subnodes
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

data/lib/loxxy/ast/lox_node.rb

@@ -11,6 +11,11 @@ module Loxxy
         @position = aPosition
       end
 
+      # Notification that the parsing was successfully completed
+      def done!
+        # Default: do nothing ...
+      end
+
       # Abstract method.
       # Part of the 'visitee' role in Visitor design pattern.
       # @param _visitor [LoxxyTreeVisitor] the visitor

data/lib/loxxy/ast/lox_noop_expr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxNoopExpr < LoxNode
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        # Do nothing...
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_print_stmt.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxPrintStmt < LoxCompoundExpr
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param anExpression [Ast::LoxNode] expression to output
+      def initialize(aPosition, anExpression)
+        super(aPosition, [anExpression])
+      end
+
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_print_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Load all the classes implementing AST nodes
+require_relative '../ast/all_lox_nodes'
+
+module Loxxy
+  module BackEnd
+    # An instance of this class executes the statements as when they
+    # occur during the abstract syntax tree walking.
+    # @note WIP: very crude implementation.
+    class Engine
+      # @return [Hash] A set of configuration options
+      attr_reader :config
+
+      # @return [Array] Data stack used for passing data between statements
+      attr_reader :stack
+
+      # @param theOptions [Hash]
+      def initialize(theOptions)
+        @config = theOptions
+        @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
+        @stack = []
+      end
+
+      # Given an abstract syntax parse tree visitor, luanch the visit
+      # and execute the visit events in the output stream.
+      # @param aVisitor [AST::ASTVisitor]
+      def execute(aVisitor)
+        aVisitor.subscribe(self)
+        aVisitor.start
+        aVisitor.unsubscribe(self)
+        stack.empty? ? Datatype::Nil.instance : stack.pop
+      end
+
+      # Visit event handling
+
+      def after_print_stmt(_printStmt)
+        tos = stack.pop
+        @ostream.print tos.to_str
+      end
+
+      # @param literalExpr [Ast::LoxLiteralExpr]
+      def before_literal_expr(literalExpr)
+        stack.push(literalExpr.literal)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -14,6 +14,12 @@ module Loxxy
         @value = validated_value(aValue)
       end
 
+      # Method called from Lox to obtain the text representation of the boolean.
+      # @return [String]
+      def to_str
+        value.to_s # Default implementation...
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/lx_string.rb

@@ -21,6 +21,12 @@ module Loxxy
         end
       end
 
+      # Method called from Lox to obtain the text representation of the object.
+      # @return [String]
+      def to_str
+        value
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/nil.rb

@@ -13,6 +13,12 @@ module Loxxy
       def initialize
         super(nil)
       end
+
+      # Method called from Lox to obtain the text representation of nil.
+      # @return [String]
+      def to_str
+        'nil'
+      end
     end # class
 
     Nil.instance.freeze # Make the sole instance immutable

data/lib/loxxy/front_end/grammar.rb

@@ -26,8 +26,8 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'EOF')
-      rule('program' => 'declaration_plus EOF')
+      rule('program' => 'EOF').as 'null_program'
+      rule('program' => 'declaration_plus EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
       rule('declaration_plus' => 'declaration_plus declaration')
@@ -73,7 +73,7 @@ module Loxxy
       rule('elsePart_opt' => 'ELSE statement')
       rule('elsePart_opt' => [])
 
-      rule('printStmt' => 'PRINT expression SEMICOLON')
+      rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
       rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
@@ -88,37 +88,37 @@ module Loxxy
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
       rule('logic_or' => 'logic_and')
-      rule('logic_or' => 'logic_and disjunct_plus')
-      rule('disjunct_plus' => 'disjunct_plus OR logic_and')
-      rule('disjunct_plus' => 'OR logic_and')
+      rule('logic_or' => 'logic_and disjunct_plus').as 'logic_or_plus'
+      rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'logic_or_plus_more'
+      rule('disjunct_plus' => 'OR logic_and').as 'logic_or_plus_end'
       rule('logic_and' => 'equality')
-      rule('logic_and' => 'equality conjunct_plus')
-      rule('conjunct_plus' => 'conjunct_plus AND equality')
-      rule('conjunct_' => 'AND equality')
+      rule('logic_and' => 'equality conjunct_plus').as 'logic_and_plus'
+      rule('conjunct_plus' => 'conjunct_plus AND equality').as 'logic_and_plus_more'
+      rule('conjunct_plus' => 'AND equality').as 'logic_and_plus_end'
       rule('equality' => 'comparison')
-      rule('equality' => 'comparison equalityTest_plus')
-      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
-      rule('equalityTest_star' => 'equalityTest comparison')
+      rule('equality' => 'comparison equalityTest_plus').as 'equality_plus'
+      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison').as 'equality_t_plus_more'
+      rule('equalityTest_plus' => 'equalityTest comparison').as 'equality_t_plus_end'
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
       rule('comparison' => 'term')
-      rule('comparison' => 'term comparisonTest_plus')
-      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term')
-      rule('comparisonTest_plus' => 'comparisonTest term')
+      rule('comparison' => 'term comparisonTest_plus').as 'comparison_plus'
+      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
+      rule('comparisonTest_plus' => 'comparisonTest term').as 'comparison_t_plus_end'
       rule('comparisonTest' => 'GREATER')
       rule('comparisonTest' => 'GREATER_EQUAL')
       rule('comparisonTest' => 'LESS')
       rule('comparisonTest' => 'LESS_EQUAL')
       rule('term' => 'factor')
-      rule('term' => 'factor additive_plus')
-      rule('additive_plus' => 'additive_plus additionOp factor').as 'additionOp_expr'
-      rule('additive_plus' => 'additionOp factor')
+      rule('term' => 'factor additive_plus').as 'term_additive'
+      rule('additive_plus' => 'additive_plus additionOp factor').as 'additive_plus_more'
+      rule('additive_plus' => 'additionOp factor').as 'additive_plus_end'
       rule('additionOp' => 'MINUS')
       rule('additionOp' => 'PLUS')
       rule('factor' => 'unary')
-      rule('factor' => 'multiplicative_plus')
-      rule('multiplicative_plus' => 'multiplicative_plus multOp unary') # .as 'multOp_expr'
-      rule('multiplicative_plus' => 'multOp unary')
+      rule('factor' => 'unary multiplicative_plus').as 'factor_multiplicative'
+      rule('multiplicative_plus' => 'multiplicative_plus multOp unary').as 'multiplicative_plus_more'
+      rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
       rule('unary' => 'unaryOp unary')

data/lib/loxxy/interpreter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative './front_end/parser'
+require_relative './ast/ast_visitor'
+require_relative './back_end/engine'
+
+module Loxxy
+  # A Lox tree-walking interpreter.
+  # It acts as a facade object that:
+  # - hides the internal plumbings of the front-end and back-end parts.
+  # - delegates all the core work to its subordinate objects.
+  # @note WIP: very crude implementation.
+  class Interpreter
+    # return [Hash]
+    attr_reader :config
+
+    # @param theOptions [Hash]
+    def initialize(theOptions = {})
+      @config = theOptions
+    end
+
+    # Evaluate the given Lox program
+    # @param lox_input [String] Lox program to evaluate
+    def evaluate(lox_input)
+      # Front-end scans, parses the input and blurps an AST...
+      parser = FrontEnd::Parser.new
+
+      # The AST is the data object passed to the back-end
+      ast_tree = parser.parse(lox_input)
+      visitor = Ast::ASTVisitor.new(ast_tree)
+
+      # Back-end launches the tree walking & reponds to visit events
+      # by executing the code determined by the visited AST node.
+      engine = BackEnd::Engine.new(config)
+      engine.execute(visitor)
+    end
+  end # class
+end # module

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'stringio'
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/engine'
+
+module Loxxy
+  module BackEnd
+    describe Engine do
+      let(:sample_options) do
+        { ostream: StringIO.new }
+      end
+      subject { Engine.new(sample_options) }
+
+      context 'Initialization:' do
+        it 'should accept a option Hash at initialization' do
+          expect { Engine.new(sample_options) }.not_to raise_error
+        end
+
+        it 'should know its config options' do
+          expect(subject.config).to eq(sample_options)
+        end
+
+        it 'should have an empty stack' do
+          expect(subject.stack).to be_empty
+        end
+      end
+
+      context 'Listening to visitor events:' do
+        let(:greeting) { Datatype::LXString.new('Hello, world') }
+        let(:sample_pos) { double('fake-position') }
+        let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
+
+        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)
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/boolean_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/boolean'
+
+module Loxxy
+  module Datatype
+    describe Boolean do
+      let(:thruth_value) { false }
+      subject { Boolean.new(thruth_value) }
+
+      context 'Initialization:' do
+        it 'should accept a boolean value at initialization' do
+          expect { Boolean.new(thruth_value) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(thruth_value)
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq('false')
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/lx_string_spec.rb

@@ -22,6 +22,10 @@ module Loxxy
       end
 
       context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq(sample_text)
+        end
+
         it 'compares with another string' do
           expect(subject).to eq(sample_text)
           expect(subject).to eq(LXString.new(sample_text.dup))

data/spec/datatype/nil_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/boolean'
+
+module Loxxy
+  module Datatype
+    describe Nil do
+      subject { Nil.instance }
+
+      context 'Initialization:' do
+        it 'should know its value' do
+          expect(subject.value).to be_nil
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq('nil')
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/number_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/number'
+
+module Loxxy
+  module Datatype
+    describe Number do
+      let(:sample_value) { -12.34 }
+      subject { Number.new(sample_value) }
+
+      context 'Initialization:' do
+        it 'should accept a Numeric value at initialization' do
+          expect { Number.new(sample_value) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(sample_value)
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq(sample_value.to_s)
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/front_end/parser_spec.rb

@@ -37,7 +37,7 @@ module Loxxy
           # Parse results MUST to comply to grammar rule:
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
-          expect(aParseTree.root.symbol.name).to eq('EOF')
+          expect(aParseTree.root).to be_kind_of(Ast::LoxNoopExpr)
         end
 
         it 'should cope with an empty input' do
@@ -64,7 +64,7 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          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 +72,7 @@ module Loxxy
         it 'should parse a true literal' do
           input = 'true;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          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 +81,7 @@ module Loxxy
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = walk_subnodes(ptree.root, [0, 0])
+            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 +96,7 @@ module Loxxy
           ]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = walk_subnodes(ptree.root, [0, 0])
+            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 +106,7 @@ module Loxxy
         it 'should parse a nil literal' do
           input = 'nil;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -119,31 +119,227 @@ module Loxxy
             print "Hello, world!";
 LOX_END
           ptree = subject.parse(program)
-          root = ptree.root
-          expect(root.symbol.name).to eq('program')
-          (prnt_stmt, eof) = root.subnodes
-          expect(prnt_stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(prnt_stmt.symbol.name).to eq('printStmt')
-          expect(prnt_stmt.subnodes.size).to eq(3)
-          expect(prnt_stmt.subnodes[0]).to be_kind_of(Rley::PTree::TerminalNode)
-          expect(prnt_stmt.subnodes[0].symbol.name).to eq('PRINT')
-          expect(prnt_stmt.subnodes[1]).to be_kind_of(Loxxy::Ast::LoxLiteralExpr)
-          expect(prnt_stmt.subnodes[1].literal).to be_kind_of(Loxxy::Datatype::LXString)
-          expect(prnt_stmt.subnodes[1].literal.value).to eq('Hello, world!')
-          expect(prnt_stmt.subnodes[2]).to be_kind_of(Rley::PTree::TerminalNode)
-          expect(prnt_stmt.subnodes[2].symbol.name).to eq('SEMICOLON')
-          expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
-          expect(eof.symbol.name).to eq('EOF')
+          prnt_stmt = ptree.root
+          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)
+          expect(prnt_stmt.subnodes[0].literal.value).to eq('Hello, world!')
         end
       end # context
 
-      context 'Parsing literals:' do
+      context 'Parsing arithmetic operations' do
         it 'should parse the addition of two number literals' do
-          # input = '123 + 456;'
-          # ptree = subject.parse(input)
-          # term = walk_subnodes(ptree.root, [0, 0, 0, 0, 0, 0, 0])
-          # expect(leaf).to be_kind_of(Ast::LoxBinaryExpr)
-          # expect(leaf.literal).to be_equal(Datatype::False.instance)
+          input = '123 + 456;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq(123)
+          expect(expr.operands[1].literal.value).to eq(456)
+        end
+
+        it 'should parse the subtraction of two number literals' do
+          input = '4 - 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:-)
+          expect(expr.operands[0].literal.value).to eq(4)
+          expect(expr.operands[1].literal.value).to eq(3)
+        end
+
+        it 'should parse multiple additive operations' do
+          input = '5 + 2 - 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.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)
+          expect(expr.operands[0].operator).to eq(:+)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to eq(3)
+        end
+
+        it 'should parse the division of two number literals' do
+          input = '8 / 2;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:/)
+          expect(expr.operands[0].literal.value).to eq(8)
+          expect(expr.operands[1].literal.value).to eq(2)
+        end
+
+        it 'should parse the product of two number literals' do
+          input = '12.34 * 0.3;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.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)
+          expect(expr.operands[1].literal.value).to eq(0.3)
+        end
+
+        it 'should parse multiple multiplicative operations' do
+          input = '5 * 2 / 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.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)
+          expect(expr.operands[0].operator).to eq(:*)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to eq(3)
+        end
+
+        it 'should parse combination of terms and factors' do
+          input = '5 + 2 / 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq(5)
+          expect(expr.operands[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[1].operator).to eq(:/)
+          expect(expr.operands[1].operands[0].literal.value).to eq(2)
+          expect(expr.operands[1].operands[1].literal.value).to eq(3)
+        end
+      end # context
+
+      context 'Parsing string concatenation' do
+        it 'should parse the concatenation of two string literals' do
+          input = '"Lo" + "ve";'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq('Lo')
+          expect(expr.operands[1].literal.value).to eq('ve')
+        end
+      end # context
+
+      context 'Parsing comparison expressions' do
+      it 'should parse the comparison of two number literals' do
+        %w[> >= < <=].each do |predicate|
+          input = "3 #{predicate} 2;"
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.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)
+          expect(expr.operands[1].literal.value).to eq(2)
+        end
+      end
+      end # context
+
+      context 'Parsing equality expressions' do
+        it 'should parse the equality of two number literals' do
+          %w[!= ==].each do |predicate|
+            input = "3 #{predicate} 2;"
+            ptree = subject.parse(input)
+            parent = ptree.root
+            expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(parent.symbol.name).to eq('exprStmt')
+            expr = parent.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)
+            expect(expr.operands[1].literal.value).to eq(2)
+          end
+        end
+
+        it 'should parse combination of equality expressions' do
+          input = '5 != 2 == false; // A bit contrived example'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.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)
+          expect(expr.operands[0].operator).to eq(:!=)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to be_falsey
+        end
+      end # context
+
+      context 'Parsing logical expressions' do
+        it 'should parse the logical operations betweentwo sub-expression' do
+          %w[or and].each do |connector|
+            input = "5 > 2 #{connector} 3 <= 4;"
+            ptree = subject.parse(input)
+            parent = ptree.root
+            expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(parent.symbol.name).to eq('exprStmt')
+            expr = parent.subnodes[0]
+            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            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(:>)
+            expect(expr.operands[0].operands[0].literal.value).to eq(5)
+            expect(expr.operands[0].operands[1].literal.value).to eq(2)
+            expect(expr.operands[1]).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operands[1].operator).to eq(:<=)
+            expect(expr.operands[1].operands[0].literal.value).to eq(3)
+            expect(expr.operands[1].operands[1].literal.value).to eq(4)
+          end
+        end
+
+        it 'should parse a combinations of logical expressions' do
+          input = '4 > 3 and 1 < 2 or 4 >= 5;'
+          ptree = subject.parse(input)
+          parent = ptree.root
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          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].operator).to eq(:and)
+          conjuncts = expr.operands[0].operands
+          expect(conjuncts[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(conjuncts[0].operator).to eq(:>)
+          expect(conjuncts[0].operands[0].literal.value).to eq(4)
+          expect(conjuncts[0].operands[1].literal.value).to eq(3)
+          expect(conjuncts[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(conjuncts[1].operator).to eq(:<)
+          expect(conjuncts[1].operands[0].literal.value).to eq(1)
+          expect(conjuncts[1].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[1].operator).to eq(:>=)
+          expect(expr.operands[1].operands[0].literal.value).to eq(4)
+          expect(expr.operands[1].operands[1].literal.value).to eq(5)
         end
       end # context
     end # describe