loxxy 0.4.09 → 0.4.10

data/spec/front_end/parser_spec.rb

@@ -8,7 +8,7 @@ require_relative '../../lib/loxxy/front_end/parser'
 module Loxxy
   module FrontEnd
     describe Parser do
-      subject { Parser.new }
+      subject(:parser) { described_class.new }
 
       # Utility method to walk towards deeply nested node
       # @param aNTNode [Rley::PTree::NonTerminalNode]
@@ -23,12 +23,12 @@ module Loxxy
       end
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Parser.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should have its parse engine initialized' do
-          expect(subject.engine).to be_kind_of(Rley::Engine)
+        it 'has its parse engine initialized' do
+          expect(parser.engine).to be_a(Rley::Engine)
         end
       end # context
 
@@ -37,173 +37,173 @@ module Loxxy
           # Parse results MUST to comply to grammar rule:
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
-          expect(aParseTree.root).to be_kind_of(Ast::LoxNoopExpr)
+          expect(aParseTree.root).to be_a(Ast::LoxNoopExpr)
         end
 
-        it 'should cope with an empty input' do
-          ptree = subject.parse('')
+        it 'copes with an empty input' do
+          ptree = parser.parse('')
           check_empty_input_result(ptree)
         end
 
-        it 'should cope with whitespaces only input' do
-          ptree = subject.parse((' ' * 80) + ("\n" * 20))
+        it 'copes with whitespaces only input' do
+          ptree = parser.parse((' ' * 80) + ("\n" * 20))
           check_empty_input_result(ptree)
         end
 
-        it 'should cope with comments only input' do
+        it 'copes with comments only input' do
           input = +''
           %w[First Second Third].each do |ordinal|
             input << "// #{ordinal} comment line\r\n"
           end
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           check_empty_input_result(ptree)
         end
       end # context
 
       context 'Parsing literals:' do
-        it 'should parse a false literal' do
+        it 'parses a false literal' do
           input = 'false;'
-          ptree = subject.parse(input)
-          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          ptree = parser.parse(input)
+          expect(ptree.root).to be_a(Ast::LoxSeqDecl)
           leaf = ptree.root.subnodes[0]
-          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
-          expect(leaf.literal).to be_equal(Datatype::False.instance)
+          expect(leaf).to be_a(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to equal(Datatype::False.instance)
         end
 
-        it 'should parse a true literal' do
+        it 'parses a true literal' do
           input = 'true;'
-          ptree = subject.parse(input)
-          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          ptree = parser.parse(input)
+          expect(ptree.root).to be_a(Ast::LoxSeqDecl)
           leaf = ptree.root.subnodes[0]
-          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
-          expect(leaf.literal).to be_equal(Datatype::True.instance)
+          expect(leaf).to be_a(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to equal(Datatype::True.instance)
         end
 
-        it 'should parse number literals' do
+        it 'parses number literals' do
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
-            ptree = subject.parse(source)
+            ptree = parser.parse(source)
             leaf = ptree.root.subnodes[0]
-            expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
-            expect(leaf.literal).to be_kind_of(Datatype::Number)
+            expect(leaf).to be_a(Ast::LoxLiteralExpr)
+            expect(leaf.literal).to be_a(Datatype::Number)
             expect(leaf.literal.value).to eq(source.to_f)
           end
         end
 
-        it 'should parse string literals' do
+        it 'parses string literals' do
           inputs = [
             '"I am a string";',
             '"";',
             '"123";'
           ]
           inputs.each do |source|
-            ptree = subject.parse(source)
+            ptree = parser.parse(source)
             leaf = ptree.root.subnodes[0]
-            expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
-            expect(leaf.literal).to be_kind_of(Datatype::LXString)
+            expect(leaf).to be_a(Ast::LoxLiteralExpr)
+            expect(leaf.literal).to be_a(Datatype::LXString)
             expect(leaf.literal.value).to eq(source.gsub(/(^")|(";$)/, ''))
           end
         end
 
-        it 'should parse a nil literal' do
+        it 'parses a nil literal' do
           input = 'nil;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           leaf = ptree.root.subnodes[0]
-          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
-          expect(leaf.literal).to be_equal(Datatype::Nil.instance)
+          expect(leaf).to be_a(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to equal(Datatype::Nil.instance)
         end
       end
 
       context 'Parsing expressions:' do
-        it 'should parse a hello world program' do
+        it 'parses a hello world program' do
           program = <<-LOX_END
             // Your first Lox program!
             print "Hello, world!";
 LOX_END
-          ptree = subject.parse(program)
+          ptree = parser.parse(program)
           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)
+          expect(prnt_stmt).to be_a(Ast::LoxPrintStmt)
+          expect(prnt_stmt.subnodes[0]).to be_a(Ast::LoxLiteralExpr)
+          expect(prnt_stmt.subnodes[0].literal).to be_a(Loxxy::Datatype::LXString)
           expect(prnt_stmt.subnodes[0].literal.value).to eq('Hello, world!')
         end
       end # context
 
       context 'Parsing arithmetic operations' do
-        it 'should parse the addition of two number literals' do
+        it 'parses the addition of two number literals' do
           input = '123 + 456;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(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
+        it 'parses the subtraction of two number literals' do
           input = '4 - 3;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(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
+        it 'parses multiple additive operations' do
           input = '5 + 2 - 3;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
-          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0]).to be_a(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
+        it 'parses the division of two number literals' do
           input = '8 / 2;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(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
+        it 'parses the product of two number literals' do
           input = '12.34 * 0.3;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(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
+        it 'parses multiple multiplicative operations' do
           input = '5 * 2 / 3;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
-          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0]).to be_a(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
+        it 'parses combination of terms and factors' do
           input = '5 + 2 / 3;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(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]).to be_a(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)
@@ -211,11 +211,11 @@ LOX_END
       end # context
 
       context 'Parsing string concatenation' do
-        it 'should parse the concatenation of two string literals' do
+        it 'parses the concatenation of two string literals' do
           input = '"Lo" + "ve";'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(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')
@@ -223,12 +223,12 @@ LOX_END
       end # context
 
       context 'Parsing comparison expressions' do
-      it 'should parse the comparison of two number literals' do
+      it 'parses the comparison of two number literals' do
         %w[> >= < <=].each do |predicate|
           input = "3 #{predicate} 2;"
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(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)
@@ -237,25 +237,25 @@ LOX_END
       end # context
 
       context 'Parsing equality expressions' do
-        it 'should parse the equality of two number literals' do
+        it 'parses the equality of two number literals' do
           %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
-            ptree = subject.parse(input)
+            ptree = parser.parse(input)
             expr = ptree.root.subnodes[0]
-            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr).to be_a(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
+        it 'parses combination of equality expressions' do
           input = '5 != 2 == false; // A bit contrived example'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_a(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:==)
-          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0]).to be_a(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)
@@ -264,42 +264,42 @@ LOX_END
       end # context
 
       context 'Parsing logical expressions' do
-        it 'should parse the logical operations between two sub-expression' do
+        it 'parses the logical operations between two sub-expression' do
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
-            ptree = subject.parse(input)
+            ptree = parser.parse(input)
             expr = ptree.root.subnodes[0]
-            expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
+            expect(expr).to be_a(Ast::LoxLogicalExpr)
             expect(expr.operator).to eq(connector.to_sym)
-            expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operands[0]).to be_a(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]).to be_a(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
+        it 'parses a combinations of logical expressions' do
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
+          expect(expr).to be_a(Ast::LoxLogicalExpr)
           expect(expr.operator).to eq(:or) # or has lower precedence than and
-          expect(expr.operands[0]).to be_kind_of(Ast::LoxLogicalExpr)
+          expect(expr.operands[0]).to be_a(Ast::LoxLogicalExpr)
           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]).to be_a(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]).to be_a(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]).to be_a(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)
@@ -307,18 +307,18 @@ LOX_END
       end # context
 
       context 'Object orientation:' do
-        it 'should parse object property get access' do
+        it 'parses object property get access' do
           input = 'print someObject.someProperty;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxPrintStmt)
+          expect(expr).to be_a(Ast::LoxPrintStmt)
           get_expr = expr.subnodes[0]
-          expect(get_expr).to be_kind_of(Ast::LoxGetExpr)
+          expect(get_expr).to be_a(Ast::LoxGetExpr)
           expect(get_expr.object.name).to eq('someObject')
           expect(get_expr.property).to eq('someProperty')
         end
 
-        it 'should parse nested call expressions' do
+        it 'parses nested call expressions' do
           input = 'print egg.scramble(3).with(cheddar);'
           # From section 12.3.1, one expects something like:
           # LoxCallExpr
@@ -330,34 +330,34 @@ LOX_END
           #       +- callee = LoxGetExpr
           #          +- property = 'scramble'
           #          +- object = variable 'egg'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           print_stmt = ptree.root.subnodes[0]
-          expect(print_stmt).to be_kind_of(Ast::LoxPrintStmt)
+          expect(print_stmt).to be_a(Ast::LoxPrintStmt)
           outer_call = print_stmt.subnodes[0]
-          expect(outer_call).to be_kind_of(Ast::LoxCallExpr)
+          expect(outer_call).to be_a(Ast::LoxCallExpr)
           expect(outer_call.arguments[0].name).to eq('cheddar')
-          expect(outer_call.callee).to be_kind_of(Ast::LoxGetExpr)
+          expect(outer_call.callee).to be_a(Ast::LoxGetExpr)
           expect(outer_call.callee.property).to eq('with')
           inner_call = outer_call.callee.object
-          expect(inner_call).to be_kind_of(Ast::LoxCallExpr)
+          expect(inner_call).to be_a(Ast::LoxCallExpr)
           expect(inner_call.arguments[0].literal).to eq(3)
-          expect(inner_call.callee).to be_kind_of(Ast::LoxGetExpr)
+          expect(inner_call.callee).to be_a(Ast::LoxGetExpr)
           expect(inner_call.callee.property).to eq('scramble')
           expect(inner_call.callee.object.name).to eq('egg')
         end
 
-        it 'should parse object property set access' do
+        it 'parses object property set access' do
           input = 'someObject.someProperty = value;'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxSetExpr)
+          expect(expr).to be_a(Ast::LoxSetExpr)
           expect(expr.object.name).to eq('someObject')
           expect(expr.property).to eq('someProperty')
-          expect(expr.value).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.value).to be_a(Ast::LoxVariableExpr)
           expect(expr.value.name).to eq('value')
         end
 
-        it 'should parse complex set access' do
+        it 'parses complex set access' do
           input = 'breakfast.omelette.filling.meat = ham;'
           # From section 12.3.2, one expects something like:
           # LoxSetExpr
@@ -368,17 +368,17 @@ LOX_END
           #    +- object = LoxGetExpr
           #       +- property = 'omelette'
           #       +- object = LoxVariableExpr 'breakfast'
-          ptree = subject.parse(input)
+          ptree = parser.parse(input)
           expr = ptree.root.subnodes[0]
-          expect(expr).to be_kind_of(Ast::LoxSetExpr)
+          expect(expr).to be_a(Ast::LoxSetExpr)
           expect(expr.property).to eq('meat')
-          expect(expr.value).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.value).to be_a(Ast::LoxVariableExpr)
           expect(expr.value.name).to eq('ham')
-          expect(expr.object).to be_kind_of(Ast::LoxGetExpr)
+          expect(expr.object).to be_a(Ast::LoxGetExpr)
           expect(expr.object.property).to eq('filling')
-          expect(expr.object.object).to be_kind_of(Ast::LoxGetExpr)
+          expect(expr.object.object).to be_a(Ast::LoxGetExpr)
           expect(expr.object.object.property).to eq('omelette')
-          expect(expr.object.object.object).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.object.object.object).to be_a(Ast::LoxVariableExpr)
           expect(expr.object.object.object.name).to eq('breakfast')
         end
       end # context

data/spec/front_end/raw_parser_spec.rb

@@ -8,15 +8,15 @@ require_relative '../../lib/loxxy/front_end/raw_parser'
 module Loxxy
   module FrontEnd
     describe RawParser do
-      subject { RawParser.new }
+      subject(:raw_parser) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { RawParser.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should have its parse engine initialized' do
-          expect(subject.engine).to be_kind_of(Rley::Engine)
+        it 'has its parse engine initialized' do
+          expect(raw_parser.engine).to be_a(Rley::Engine)
         end
       end # context
 
@@ -27,29 +27,29 @@ module Loxxy
           #   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).to be_a(Rley::PTree::NonTerminalNode)
           expect(decls.symbol.name).to eq('rep_declaration_star')
           expect(decls.subnodes).to be_empty
-          expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
+          expect(eof).to be_a(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
 
-        it 'should cope with an empty input' do
-          ptree = subject.parse('')
+        it 'copes with an empty input' do
+          ptree = raw_parser.parse('')
           check_empty_input_result(ptree)
         end
 
-        it 'should cope with whitespaces only input' do
-          ptree = subject.parse((' ' * 80) + ("\n" * 20))
+        it 'copes with whitespaces only input' do
+          ptree = raw_parser.parse((' ' * 80) + ("\n" * 20))
           check_empty_input_result(ptree)
         end
 
-        it 'should cope with comments only input' do
+        it 'copes with comments only input' do
           input = +''
           %w[First Second Third].each do |ordinal|
             input << "// #{ordinal} comment line\r\n"
           end
-          ptree = subject.parse(input)
+          ptree = raw_parser.parse(input)
           check_empty_input_result(ptree)
         end
       end # context
@@ -66,37 +66,37 @@ module Loxxy
 
           curr_node
         end
-        it 'should parse a hello world program' do
+        it 'parses a hello world program' do
           program = <<-LOX_END
             // Your first Lox program!
             print "Hello, world!";
 LOX_END
-          ptree = subject.parse(program)
+          ptree = raw_parser.parse(program)
           root = ptree.root
           expect(root.symbol.name).to eq('program')
           (decls, eof) = root.subnodes
-          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls).to be_a(Rley::PTree::NonTerminalNode)
           expect(decls.symbol.name).to eq('rep_declaration_star')
-          expect(decls.subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[0]).to be_a(Rley::PTree::NonTerminalNode)
           expect(decls.subnodes[0].symbol.name).to eq('rep_declaration_star')
-          expect(decls.subnodes[1]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[1]).to be_a(Rley::PTree::NonTerminalNode)
           expect(decls.subnodes[1].symbol.name).to eq('declaration')
           statement = decls.subnodes[1].subnodes[0]
-          expect(statement).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(statement).to be_a(Rley::PTree::NonTerminalNode)
           expect(statement.symbol.name).to eq('statement')
           prnt_stmt = statement.subnodes[0]
-          expect(prnt_stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(prnt_stmt).to be_a(Rley::PTree::NonTerminalNode)
           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]).to be_a(Rley::PTree::TerminalNode)
           expect(prnt_stmt.subnodes[0].symbol.name).to eq('PRINT')
-          expect(prnt_stmt.subnodes[1]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(prnt_stmt.subnodes[1]).to be_a(Rley::PTree::NonTerminalNode)
           leaf_node = walk_subnodes(prnt_stmt, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-          expect(leaf_node).to be_kind_of(Rley::PTree::TerminalNode)
+          expect(leaf_node).to be_a(Rley::PTree::TerminalNode)
           expect(leaf_node.symbol.name).to eq('STRING')
           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]).to be_a(Rley::PTree::TerminalNode)
           expect(prnt_stmt.subnodes[2].symbol.name).to eq('SEMICOLON')
-          expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
+          expect(eof).to be_a(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
       end