loxxy 0.0.4 → 0.0.9

data/lib/loxxy/front_end/scanner.rb

@@ -50,7 +50,7 @@ module Loxxy
         '>' => 'GREATER',
         '>=' => 'GREATER_EQUAL',
         '<' => 'LESS',
-        '<=' => 'LESS_EQUAL',
+        '<=' => 'LESS_EQUAL'
       }.freeze
 
       # Here are all the implemented Lox keywords (in uppercase)
@@ -99,7 +99,7 @@ module Loxxy
 
         token = nil
 
-        if "(){},.;/*".include? curr_ch
+        if '(){},.;/*'.include? curr_ch
           # Single delimiter or separator character
           token = build_token(@@lexeme2name[curr_ch], scanner.getch)
         elsif (lexeme = scanner.scan(/[+\-](?!\d)/))
@@ -150,7 +150,7 @@ module Loxxy
           when 'FALSE'
             value = Datatype::False.instance
           when 'NIL'
-            value = Datatype::Nil.instance            
+            value = Datatype::Nil.instance
           when 'NUMBER'
             value = Datatype::Number.new(aLexeme)
           when 'STRING'
@@ -167,8 +167,6 @@ module Loxxy
       # Skip non-significant whitespaces and comments.
       # Advance the scanner until something significant is found.
       def skip_intertoken_spaces
-        pre_pos = scanner.pos
-
         loop do
           ws_found = scanner.skip(/[ \t\f]+/) ? true : false
           nl_found = scanner.skip(/(?:\r\n)|\r|\n/)
@@ -191,7 +189,7 @@ module Loxxy
           break unless ws_found || cmt_found
         end
 
-        curr_pos = scanner.pos
+        scanner.pos
       end
 
       def skip_block_comment

data/lib/loxxy/version.rb

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

data/loxxy.gemspec

@@ -40,8 +40,8 @@ Gem::Specification.new do |spec|
   spec.version       = Loxxy::VERSION
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
-  spec.summary       = %q{An implementation of the Lox programming language. WIP}
-  spec.description   = %q{An implementation of the Lox programming language. WIP}
+  spec.summary       = 'An implementation of the Lox programming language. WIP'
+  spec.description   = 'An implementation of the Lox programming language. WIP'
   spec.homepage      = 'https://github.com/famished-tiger/loxxy'
   spec.license       = 'MIT'
   spec.required_ruby_version = '~> 2.4'

data/spec/datatype/lx_string_spec.rb

@@ -1,35 +1,35 @@
-# frozen_string_literal: true
-
-require_relative '../spec_helper' # Use the RSpec framework
-
-# Load the class under test
-require_relative '../../lib/loxxy/datatype/lx_string'
-
-module Loxxy
-  module Datatype
-    describe LXString do
-      let(:sample_text) { 'some_text' }
-      subject { LXString.new(sample_text) }
-      
-      context 'Initialization:' do
-        it 'should accept a String value at initialization' do
-          expect { LXString.new(sample_text) }.not_to raise_error
-        end
-        
-        it 'should know its value' do
-          expect(subject.value).to eq(sample_text)
-        end
-      end
-
-      context 'Provided services:' do
-        it 'compares with another string' do
-          expect(subject).to eq(sample_text)
-          expect(subject).to eq(LXString.new(sample_text.dup))
-
-          expect(subject).not_to eq('')
-          expect(subject).not_to eq('other-text')
-        end
-      end
-    end # describe
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/lx_string'
+
+module Loxxy
+  module Datatype
+    describe LXString do
+      let(:sample_text) { 'some_text' }
+      subject { LXString.new(sample_text) }
+
+      context 'Initialization:' do
+        it 'should accept a String value at initialization' do
+          expect { LXString.new(sample_text) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(sample_text)
+        end
+      end
+
+      context 'Provided services:' do
+        it 'compares with another string' do
+          expect(subject).to eq(sample_text)
+          expect(subject).to eq(LXString.new(sample_text.dup))
+
+          expect(subject).not_to eq('')
+          expect(subject).not_to eq('other-text')
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/front_end/parser_spec.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/front_end/parser'
+
+module Loxxy
+  module FrontEnd
+    describe Parser do
+      subject { Parser.new }
+
+      # Utility method to walk towards deeply nested node
+      # @param aNTNode [Rley::PTree::NonTerminalNode]
+      # @param subnodePath[Array<Integer>] An Array of subnode indices
+      def walk_subnodes(aNTNode, subnodePath)
+        curr_node = aNTNode
+        subnodePath.each do |index|
+          curr_node = curr_node.subnodes[index]
+        end
+
+        curr_node
+      end
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Parser.new }.not_to raise_error
+        end
+
+        it 'should have its parse engine initialized' do
+          expect(subject.engine).to be_kind_of(Rley::Engine)
+        end
+      end # context
+
+      context 'Parsing blank files:' do
+        def check_empty_input_result(aParseTree)
+          # 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')
+        end
+
+        it 'should cope with an empty input' do
+          ptree = subject.parse('')
+          check_empty_input_result(ptree)
+        end
+
+        it 'should cope with whitespaces only input' do
+          ptree = subject.parse(' ' * 80 + "\n" * 20)
+          check_empty_input_result(ptree)
+        end
+
+        it 'should cope with comments only input' do
+          input = +''
+          %w[First Second Third].each do |ordinal|
+            input << "// #{ordinal} comment line\r\n"
+          end
+          ptree = subject.parse(input)
+          check_empty_input_result(ptree)
+        end
+      end # context
+
+      context 'Parsing literals:' do
+        it 'should parse a false literal' do
+          input = 'false;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::False.instance)
+        end
+
+        it 'should parse a true literal' do
+          input = 'true;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::True.instance)
+        end
+
+        it 'should parse number literals' do
+          inputs = %w[1234; 12.34;]
+          inputs.each do |source|
+            ptree = subject.parse(source)
+            leaf = walk_subnodes(ptree.root, [0, 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)
+          end
+        end
+
+        it 'should parse string literals' do
+          inputs = [
+            '"I am a string";',
+            '"";',
+            '"123";'
+          ]
+          inputs.each do |source|
+            ptree = subject.parse(source)
+            leaf = walk_subnodes(ptree.root, [0, 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(/(^")|(";$)/, ''))
+          end
+        end
+
+        it 'should parse a nil literal' do
+          input = 'nil;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::Nil.instance)
+        end
+      end
+
+      context 'Parsing expressions:' do
+        it 'should parse a hello world program' do
+          program = <<-LOX_END
+            // Your first Lox program!
+            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')
+        end
+      end # context
+
+      context 'Parsing arithmetic operations' do
+        it 'should parse the addition of two number literals' do
+          input = '123 + 456;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          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.subnodes[0]
+          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.subnodes[0]
+          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.subnodes[0]
+          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.subnodes[0]
+          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.subnodes[0]
+          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.subnodes[0]
+          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.subnodes[0]
+          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.subnodes[0]
+            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
+    end # describe
+  end # module
+end # module

data/spec/front_end/raw_parser_spec.rb

@@ -26,10 +26,7 @@ module Loxxy
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
           expect(aParseTree.root.symbol.name).to eq('program')
-          (decls, eof) = aParseTree.root.subnodes
-          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_star')
-          expect(decls.subnodes).to be_empty
+          eof = aParseTree.root.subnodes.first
           expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
@@ -76,8 +73,8 @@ LOX_END
           expect(root.symbol.name).to eq('program')
           (decls, eof) = root.subnodes
           expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_star')
-          stmt = decls.subnodes[1].subnodes[0]
+          expect(decls.symbol.name).to eq('declaration_plus')
+          stmt = decls.subnodes[0].subnodes[0]
           expect(stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(stmt.symbol.name).to eq('statement')
           prnt_stmt = stmt.subnodes[0]
@@ -92,8 +89,10 @@ LOX_END
           expect(leaf_node.token.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')
         end
       end
     end # describe
   end # module
-end # module
+end # module

data/spec/front_end/scanner_spec.rb

@@ -78,7 +78,7 @@ module Loxxy
         end
 
         it 'should recognize non-datatype keywords' do
-          keywords =<<-LOX_END
+          keywords = <<-LOX_END
             and class else fun for if or
             print return super this var while
 LOX_END
@@ -167,7 +167,7 @@ LOX_END
         end
 
         it 'should recognize string values' do
-          input =<<-LOX_END
+          input = <<-LOX_END
           ""
           "string"
           "123"
@@ -223,6 +223,18 @@ LOX_END
           ]
           match_expectations(subject, expectations)
         end
+
+        it 'should cope with single slash (divide) expression' do
+          subject.start_with('8 / 2')
+
+          expectations = [
+            # [token lexeme]
+            %w[NUMBER 8],
+            %w[SLASH /],
+            %w[NUMBER 2]
+          ]
+          match_expectations(subject, expectations)
+        end
       end # context
     end # describe
   end # module