loxxy 0.4.09 → 0.4.10

data/spec/interpreter_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'spec_helper' # Use the RSpec framework
-require 'stringio'
 
 # Load the class under test
 require_relative '../lib/loxxy/interpreter'
@@ -15,57 +14,58 @@ module Loxxy
     let(:sample_cfg) do
       { ostream: StringIO.new }
     end
-    subject { Interpreter.new(sample_cfg) }
+
+    subject(:interpreter) { described_class.new(sample_cfg) }
 
     context 'Initialization:' do
-      it 'should accept a option Hash at initialization' do
-        expect { Interpreter.new(sample_cfg) }.not_to raise_error
+      it 'accepts a option Hash at initialization' do
+        expect { described_class.new(sample_cfg) }.not_to raise_error
       end
 
-      it 'should know its config options' do
-        expect(subject.config).to eq(sample_cfg)
+      it 'knows its config options' do
+        expect(interpreter.config).to eq(sample_cfg)
       end
     end # context
 
     context 'Evaluating arithmetic operations code:' do
-      it 'should evaluate an addition of two numbers' do
-        result = subject.evaluate('123 + 456; // => 579')
-        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+      it 'evaluates an addition of two numbers' do
+        result = interpreter.evaluate('123 + 456; // => 579')
+        expect(result).to be_a(Loxxy::Datatype::Number)
         expect(result == 579).to be_true
       end
 
-      it 'should evaluate a subtraction of two numbers' do
-        result = subject.evaluate('4 - 3; // => 1')
-        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+      it 'evaluates a subtraction of two numbers' do
+        result = interpreter.evaluate('4 - 3; // => 1')
+        expect(result).to be_a(Loxxy::Datatype::Number)
         expect(result == 1).to be_true
       end
 
-      it 'should evaluate a multiplication of two numbers' do
-        result = subject.evaluate('5 * 3; // => 15')
-        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+      it 'evaluates a multiplication of two numbers' do
+        result = interpreter.evaluate('5 * 3; // => 15')
+        expect(result).to be_a(Loxxy::Datatype::Number)
         expect(result == 15).to be_true
       end
 
-      it 'should evaluate a division of two numbers' do
-        result = subject.evaluate('8 / 2; // => 4')
-        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+      it 'evaluates a division of two numbers' do
+        result = interpreter.evaluate('8 / 2; // => 4')
+        expect(result).to be_a(Loxxy::Datatype::Number)
         expect(result == 4).to be_true
       end
     end # context
 
     context 'Evaluating Lox code:' do
-      it 'should evaluate core data types' do
-        result = subject.evaluate('true; // Not false')
-        expect(result).to be_kind_of(Loxxy::Datatype::True)
+      it 'evaluates core data types' do
+        result = interpreter.evaluate('true; // Not false')
+        expect(result).to be_a(Loxxy::Datatype::True)
       end
 
-      it 'should evaluate string concatenation' do
-        result = subject.evaluate('"str" + "ing"; // => "string"')
-        expect(result).to be_kind_of(Loxxy::Datatype::LXString)
+      it 'evaluates string concatenation' do
+        result = interpreter.evaluate('"str" + "ing"; // => "string"')
+        expect(result).to be_a(Loxxy::Datatype::LXString)
         expect(result == 'string').to be_true
       end
 
-      it 'should perform the equality tests of two values' do
+      it 'performs the equality tests of two values' do
         [
           ['nil == nil;', true],
           ['true == true;', true],
@@ -80,13 +80,13 @@ module Loxxy
           ['false == 0;', false],
           ['0 == "0";', false]
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should perform the inequality test of two values' do
+      it 'performs the inequality test of two values' do
         [
           ['nil != nil;', false],
           ['true != true;', false],
@@ -101,13 +101,13 @@ module Loxxy
           ['false != 0;', true],
           ['0 != "0";', true]
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should evaluate a comparison of two numbers' do
+      it 'evaluates a comparison of two numbers' do
         [
           ['1 < 2;', true],
           ['2 < 2;', false],
@@ -130,38 +130,38 @@ module Loxxy
           ['0 >= -0;', true],
           ['-0 >= 0;', true]
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should evaluate the change sign of a number' do
+      it 'evaluates the change sign of a number' do
         [
           ['- 3;', -3],
           ['- - 3;', 3],
           ['- - - 3;', -3]
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should ignore spaces surrounding minus in subtraction of two numbers' do
+      it 'ignores spaces surrounding minus in subtraction of two numbers' do
         [
           ['1 - 1;', 0],
           ['1 -1;', 0],
           ['1- 1;', 0],
           ['1-1;', 0]
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should evaluate the negation of an object' do
+      it 'evaluates the negation of an object' do
         [
           ['!true;', false],
           ['!false;', true],
@@ -171,13 +171,13 @@ module Loxxy
           ['!nil;', true],
           ['!"";', false]
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should evaluate the "conjunction" of two values' do
+      it 'evaluates the "conjunction" of two values' do
         [
           # Return the first falsey argument
           ['false and 1;', false],
@@ -194,13 +194,13 @@ module Loxxy
 
           # TODO test short-circuit at first false argument
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should evaluate the "disjunction" of two values' do
+      it 'evaluates the "disjunction" of two values' do
         [
           # Return the first truthy argument
           ['1 or true;', 1],
@@ -218,25 +218,25 @@ module Loxxy
 
           # TODO test short-circuit at first false argument
         ].each do |(source, predicted)|
-          lox = Loxxy::Interpreter.new
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should support expressions between parentheses' do
+      it 'supports 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
+          lox = described_class.new
           result = lox.evaluate(source)
           expect(result.value == predicted).to be_truthy
         end
       end
 
-      it 'should evaluate an if statement' do
+      it 'evaluates an if statement' do
         [
           # Evaluate the 'then' expression if the condition is true.
           ['if (true) print "then-branch";', 'then-branch'],
@@ -258,40 +258,40 @@ module Loxxy
         ].each do |(source, predicted)|
           io = StringIO.new
           cfg = { ostream: io }
-          lox = Loxxy::Interpreter.new(cfg)
+          lox = described_class.new(cfg)
           lox.evaluate(source)
           expect(io.string).to eq(predicted)
         end
       end
 
-      it 'should accept variable declarations' do
+      it 'accepts variable declarations' do
         # Variable with initialization value
         var_decl = 'var iAmAVariable = "here is my value";'
-        expect { subject.evaluate(var_decl) }.not_to raise_error
+        expect { interpreter.evaluate(var_decl) }.not_to raise_error
 
         # Variable without initialization value
-        expect { subject.evaluate('var iAmNil;') }.not_to raise_error
+        expect { interpreter.evaluate('var iAmNil;') }.not_to raise_error
       end
 
-      it 'should accept variable mention' do
+      it 'accepts variable mention' do
         program = <<-LOX_END
           var foo = "bar";
           print foo; // => bar
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('bar')
       end
 
-      it 'should set uninitialized variables to nil' do
+      it 'sets uninitialized variables to nil' do
         program = <<-LOX_END
         var a;
         print a; // => nil
 LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('nil')
       end
 
-      it 'should accept assignments to a global variable' do
+      it 'accepts assignments to a global variable' do
         program = <<-LOX_END
           var a = "before";
           print a; // output: before
@@ -302,11 +302,11 @@ LOX_END
           print a = "arg"; // output: arg
           print a; // output: arg
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('beforeafterargarg')
       end
 
-      it 'should support variables local to a block' do
+      it 'supports variables local to a block' do
         program = <<-LOX_END
         {
           var a = "first";
@@ -317,11 +317,11 @@ LOX_END
           print a;
         }
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('firstsecond')
       end
 
-      it 'should support the shadowing of variables in a block' do
+      it 'supports the shadowing of variables in a block' do
         program = <<-LOX_END
         var a = "outer";
 
@@ -332,11 +332,11 @@ LOX_END
 
         print a; // output: outer
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('innerouter')
       end
 
-      it 'should implement single statement while loops' do
+      it 'implements single statement while loops' do
         program = <<-LOX_END
           // Single-expression body.
           var c = 0;
@@ -345,11 +345,11 @@ LOX_END
           // output: 2
           // output: 3
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('123')
       end
 
-      it 'should implement block body while loops' do
+      it 'implements block body while loops' do
         program = <<-LOX_END
           // Block body.
           var a = 0;
@@ -361,11 +361,11 @@ LOX_END
           // output: 1
           // output: 2
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('012')
       end
 
-      it 'should implement single statement for loops' do
+      it 'implements single statement for loops' do
         program = <<-LOX_END
           // Single-expression body.
           for (var c = 0; c < 3;) print c = c + 1;
@@ -373,11 +373,11 @@ LOX_END
           // output: 2
           // output: 3
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('123')
       end
 
-      it 'should implement for loops with block body' do
+      it 'implements for loops with block body' do
         program = <<-LOX_END
           // Block body.
           for (var a = 0; a < 3; a = a + 1) {
@@ -387,81 +387,77 @@ LOX_END
           // output: 1
           // output: 2
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('012')
       end
 
-      it 'should implement nullary function calls' do
+      it 'implements nullary function calls' do
         program = <<-LOX_END
           print clock(); // Lox expects the 'clock' predefined native function
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         tick = sample_cfg[:ostream].string
         expect(Time.now.to_f - tick.to_f).to be < 0.1
       end
 
-      it 'should implement function definition' do
+      it 'implements function definition' do
         program = <<-LOX_END
           fun printSum(a, b) {
              print a + b;
           }
           printSum(1, 2);
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('3')
       end
 
-      it 'should support functions with empty body' do
+      it 'supports functions with empty body' do
         program = <<-LOX_END
           fun f() {}
           print f();
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('nil')
       end
 
-      it 'should provide print representation of functions' do
+      it 'provides print representation of functions' do
         program = <<-LOX_END
           fun foo() {}
           print foo; // output: <fn foo>
           print clock; // output: <native fn>
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('<fn foo><native fn>')
       end
 
-      it "should implement 'getc' function" do
+      it "implements 'getc' function" do
         input_str = 'Abc'
         cfg = { istream: StringIO.new(input_str) }
-        interpreter = Loxxy::Interpreter.new(cfg)
+        interpreter = described_class.new(cfg)
         source = 'getc();'
         result = interpreter.evaluate(source)
         expect(result.value).to eq(65) # codepoint for letter 'A'
       end
 
-      it "should implement 'chr' function" do
+      it "implements 'chr' function" do
         source = 'chr(65); // => "A"'
-        result = subject.evaluate(source)
+        result = interpreter.evaluate(source)
         expect(result.value).to eq('A')
       end
 
       # This test is disabled since it causes RSpec to stop immediately
-      # it "should implement 'exit' function" do
+      # it "implements 'exit' function" do
       #   source = 'exit(100); // Process halts with exit code 100'
-      #   expect { subject.evaluate(source) }.to raise(SystemExit)
+      #   expect { interpreter.evaluate(source) }.to raise(SystemExit)
       # end
 
-      it "should implement 'print_error' function" do
+      it "implements 'print_error' function" do
         source = 'print_error("Some error"); // => Some error on stderr'
-        stderr_backup = $stderr
-        $stderr = StringIO.new
-        expect { subject.evaluate(source) }.not_to raise_error
-        expect($stderr.string).to eq('Some error')
-        $stderr = stderr_backup
+        expect { interpreter.evaluate(source) }.to output('Some error').to_stderr
       end
 
       # rubocop: disable Style/StringConcatenation
-      it 'should return in absence of explicit return statement' do
+      it 'returns in absence of explicit return statement' do
         program = <<-LOX_END
           fun foo() {
             print "foo";
@@ -469,12 +465,12 @@ LOX_END
 
           print foo();
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('foo' + 'nil')
       end
       # rubocop: enable Style/StringConcatenation
 
-      it 'should support return statements' do
+      it 'supports return statements' do
         program = <<-LOX_END
           fun max(a, b) {
             if (a > b) return a;
@@ -484,23 +480,23 @@ LOX_END
 
           max(3, 2);
         LOX_END
-        result = subject.evaluate(program)
+        result = interpreter.evaluate(program)
         expect(result).to eq(3)
       end
 
-      it 'should support return within statements inside a function' do
+      it 'supports return within statements inside a function' do
         program = <<-LOX_END
           fun foo() {
             for (;;) return "done";
           }
           print foo(); // output: done
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('done')
       end
 
       # rubocop: disable Style/StringConcatenation
-      it 'should support local functions and closures' do
+      it 'supports local functions and closures' do
         program = <<-LOX_END
           fun makeCounter() {
             var i = 0;
@@ -516,17 +512,17 @@ LOX_END
           counter(); // "1".
           counter(); // "2".
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('1' + '2')
       end
       # rubocop: enable Style/StringConcatenation
 
-      it 'should print the hello world message' do
+      it 'prints the hello world message' do
         program = <<-LOX_END
           var greeting = "Hello"; // Declaring a variable
           print greeting + ", " + "world!"; // ... Playing with concatenation
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')
       end
     end # context
@@ -548,7 +544,7 @@ LOX_END
         snippet
       end
 
-      it 'should support field assignment expression' do
+      it 'supports field assignment expression' do
         program = <<-LOX_END
           class Foo {}
 
@@ -556,43 +552,43 @@ LOX_END
 
           print foo.bar = "bar value"; // expect: bar value
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('bar value')
       end
 
-      it 'should support class declaration' do
+      it 'supports class declaration' do
         program = <<-LOX_END
           #{duck_class}
 
           print Duck; // Class names can appear in statements
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Duck')
       end
 
-      it 'should support default instance creation' do
+      it 'supports default instance creation' do
         program = <<-LOX_END
           #{duck_class}
 
           var daffy = Duck(); // Default constructor
           print daffy;
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Duck instance')
       end
 
-      it 'should support calls to method' do
+      it 'supports calls to method' do
         program = <<-LOX_END
           #{duck_class}
 
           var daffy = Duck(); // Default constructor
           daffy.quack();
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('quack')
       end
 
-      it "should support the 'this' keyword" do
+      it "supports the 'this' keyword" do
         program = <<-LOX_END
           class Egotist {
             speak() {
@@ -603,11 +599,11 @@ LOX_END
           var method = Egotist().speak;
           method(); // Output: Egotist instance
         LOX_END
-        expect { subject.evaluate(program) }.not_to raise_error
+        expect { interpreter.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Egotist instance')
       end
 
-      it 'should support a closure nested in a method' do
+      it 'supports a closure nested in a method' do
         lox_snippet = <<-LOX_END
         class Foo {
           getClosure() {
@@ -635,21 +631,21 @@ LOX_END
         # Environment
         #   defns
         #   +- ['closure'] => Backend::LoxFunction
-        result = subject.evaluate(lox_snippet)
-        expect(result).to be_kind_of(BackEnd::LoxFunction)
+        result = interpreter.evaluate(lox_snippet)
+        expect(result).to be_a(BackEnd::LoxFunction)
         expect(result.name).to eq('closure')
         closure = result.closure
-        expect(closure).to be_kind_of(Loxxy::BackEnd::Environment)
+        expect(closure).to be_a(Loxxy::BackEnd::Environment)
         expect(closure.defns['closure'].value).to eq(result)
-        expect(closure.enclosing).to be_kind_of(Loxxy::BackEnd::Environment)
-        expect(closure.enclosing.defns['this'].value).to be_kind_of(Loxxy::BackEnd::LoxInstance)
+        expect(closure.enclosing).to be_a(Loxxy::BackEnd::Environment)
+        expect(closure.enclosing.defns['this'].value).to be_a(Loxxy::BackEnd::LoxInstance)
         global_env = closure.enclosing.enclosing
-        expect(global_env).to be_kind_of(Loxxy::BackEnd::Environment)
-        expect(global_env.defns['clock'].value).to be_kind_of(BackEnd::Engine::NativeFunction)
-        expect(global_env.defns['Foo'].value).to be_kind_of(BackEnd::LoxClass)
+        expect(global_env).to be_a(Loxxy::BackEnd::Environment)
+        expect(global_env.defns['clock'].value).to be_a(BackEnd::Engine::NativeFunction)
+        expect(global_env.defns['Foo'].value).to be_a(BackEnd::LoxClass)
       end
 
-      it 'should support custom initializer' do
+      it 'supports custom initializer' do
         lox_snippet = <<-LOX_END
           // From section 3.9.5
           class Breakfast {
@@ -668,12 +664,12 @@ LOX_END
           baconAndToast.serve("Dear Reader");
           // Output: "Enjoy your bacon and toast, Dear Reader."
         LOX_END
-        expect { subject.evaluate(lox_snippet) }.not_to raise_error
+        expect { interpreter.evaluate(lox_snippet) }.not_to raise_error
         predicted = 'Enjoy your bacon and toast, Dear Reader.'
         expect(sample_cfg[:ostream].string).to eq(predicted)
       end
 
-      it 'should support class inheritance and super keyword' do
+      it 'supports class inheritance and super keyword' do
         lox_snippet = <<-LOX_END
           class A {
             method() {
@@ -695,7 +691,7 @@ LOX_END
 
           C().test();
         LOX_END
-        expect { subject.evaluate(lox_snippet) }.not_to raise_error
+        expect { interpreter.evaluate(lox_snippet) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('A method')
       end
     end # context

data/spec/loxxy_spec.rb

@@ -4,6 +4,6 @@ require_relative '../lib/loxxy/version/'
 
 RSpec.describe Loxxy do
   it 'has a version number' do
-    expect(Loxxy::VERSION).not_to be nil
+    expect(Loxxy::VERSION).not_to be_nil
   end
 end