gobstones 0.0.2 → 0.0.3

data/spec/lang/expressions/comparison_expressions_spec.rb

@@ -1,282 +1,236 @@
-describe "comparison expressions" do
-
+RSpec.describe 'evaluating comparison expressions' do
   describe Equal do
-
-    it "evaluates same booleans as equal" do
-      expect(Equal.new(false_value, false_value).evaluate).to eq(true_value)
-      expect(Equal.new(true_value, true_value).evaluate).to eq(true_value)
-      expect(Equal.new(false_value, true_value).evaluate).to eq(false_value)
-      expect(Equal.new(true_value, false_value).evaluate).to eq(false_value)
+    it 'evaluates same booleans as equal' do
+      expect(described_class.new(false_value, false_value).evaluate).to eq(true_value)
+      expect(described_class.new(true_value, true_value).evaluate).to eq(true_value)
+      expect(described_class.new(false_value, true_value).evaluate).to eq(false_value)
+      expect(described_class.new(true_value, false_value).evaluate).to eq(false_value)
     end
 
-    it "evaluates same colors as equal" do
-      color_classes = [Azul, Negro, Rojo, Verde]
+    it 'evaluates same colors as equal' do
+      color_classes = Color.all
       color_classes.each do |color_class|
-        expect(Equal.new(color_class.new, color_class.new).
-          evaluate).to eq(true_value)
+        expect(described_class.new(color_class.new, color_class.new).evaluate).to eq(true_value)
         (color_classes - [color_class]).each do |different_color_class|
-          expect(Equal.new(color_class.new, different_color_class.new).
-            evaluate).to eq(false_value)
+          expect(described_class.new(color_class.new, different_color_class.new).evaluate).to eq(false_value)
         end
       end
     end
 
-    it "evaluates same directions as equal" do
-      dir_classes = [Norte, Sur, Este, Oeste]
+    it 'evaluates same directions as equal' do
+      dir_classes = Direction.all
       dir_classes.each do |dir_class|
-        expect(Equal.new(dir_class.new, dir_class.new).
-          evaluate).to eq(true_value)
+        expect(described_class.new(dir_class.new, dir_class.new).evaluate).to eq(true_value)
         (dir_classes - [dir_class]).each do |different_dir_class|
-          expect(Equal.new(dir_class.new, different_dir_class.new).
-            evaluate).to eq(false_value)
+          expect(described_class.new(dir_class.new, different_dir_class.new).evaluate).to eq(false_value)
         end
       end
     end
 
-    it "evaluates same numbers as equal" do
-      expect(Equal.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
-      expect(Equal.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
+    it 'evaluates same numbers as equal' do
+      expect(described_class.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
+      expect(described_class.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
     end
-
   end
 
   describe NotEqual do
-
-    it "evaluates booleans as not equal" do
-      expect(NotEqual.new(false_value, false_value).evaluate).to eq(false_value)
-      expect(NotEqual.new(true_value, true_value).evaluate).to eq(false_value)
-      expect(NotEqual.new(false_value, true_value).evaluate).to eq(true_value)
-      expect(NotEqual.new(true_value, false_value).evaluate).to eq(true_value)
+    it 'evaluates booleans as not equal' do
+      expect(described_class.new(false_value, false_value).evaluate).to eq(false_value)
+      expect(described_class.new(true_value, true_value).evaluate).to eq(false_value)
+      expect(described_class.new(false_value, true_value).evaluate).to eq(true_value)
+      expect(described_class.new(true_value, false_value).evaluate).to eq(true_value)
     end
 
-    it "evaluates same colors as equal" do
-      color_classes = [Azul, Negro, Rojo, Verde]
+    it 'evaluates same colors as equal' do
+      color_classes = Color.all
       color_classes.each do |color_class|
-        expect(NotEqual.new(color_class.new, color_class.new).
-          evaluate).to eq(false_value)
+        expect(described_class.new(color_class.new, color_class.new).evaluate).to eq(false_value)
         (color_classes - [color_class]).each do |different_color_class|
-          expect(NotEqual.new(color_class.new, different_color_class.new).
-            evaluate).to eq(true_value)
+          expect(described_class.new(color_class.new, different_color_class.new).evaluate).to eq(true_value)
         end
       end
     end
 
-    it "evaluates same directions as equal" do
-      dir_classes = [Norte, Sur, Este, Oeste]
+    it 'evaluates same directions as equal' do
+      dir_classes = Direction.all
       dir_classes.each do |dir_class|
-        expect(NotEqual.new(dir_class.new, dir_class.new).
-          evaluate).to eq(false_value)
+        expect(described_class.new(dir_class.new, dir_class.new).evaluate).to eq(false_value)
         (dir_classes - [dir_class]).each do |different_dir_class|
-          expect(NotEqual.new(dir_class.new, different_dir_class.new).
-            evaluate).to eq(true_value)
+          expect(described_class.new(dir_class.new, different_dir_class.new).evaluate).to eq(true_value)
         end
       end
     end
 
-    it "evaluates same numbers as equal" do
-      expect(NotEqual.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
-      expect(NotEqual.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
+    it 'evaluates same numbers as equal' do
+      expect(described_class.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
+      expect(described_class.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
     end
-
   end
 
   describe LessThan do
-
-    it "evaluates for booleans" do
-      expect(LessThan.new(false_value, false_value).evaluate).to eq(false_value)
-      expect(LessThan.new(false_value, true_value).evaluate).to eq(true_value)
-      expect(LessThan.new(true_value, false_value).evaluate).to eq(false_value)
-      expect(LessThan.new(true_value, true_value).evaluate).to eq(false_value)
+    it 'evaluates for booleans' do
+      expect(described_class.new(false_value, false_value).evaluate).to eq(false_value)
+      expect(described_class.new(false_value, true_value).evaluate).to eq(true_value)
+      expect(described_class.new(true_value, false_value).evaluate).to eq(false_value)
+      expect(described_class.new(true_value, true_value).evaluate).to eq(false_value)
     end
 
-    it "evaluates for numbers" do
-      expect(LessThan.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
-      expect(LessThan.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
-      expect(LessThan.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
+    it 'evaluates for numbers' do
+      expect(described_class.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
+      expect(described_class.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
+      expect(described_class.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
     end
 
-    it "evaluates for colors" do
+    it 'evaluates for colors' do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
         # should not be less than itself
-        expect(LessThan.new(color_class.new, color_class.new).
-          evaluate).to eq(false_value)
+        expect(described_class.new(color_class.new, color_class.new).evaluate).to eq(false_value)
         color_classes.take(index).each do |previous_color_class|
           # should not be less than any previous value
-          expect(LessThan.new(color_class.new, previous_color_class.new).
-            evaluate).to eq(false_value)
+          expect(described_class.new(color_class.new, previous_color_class.new).evaluate).to eq(false_value)
         end
-        color_classes.drop(index+1).each do |next_color_class|
+        color_classes.drop(index + 1).each do |next_color_class|
           # should be less than any next value
-          expect(LessThan.new(color_class.new, next_color_class.new).
-            evaluate).to eq(true_value)
+          expect(described_class.new(color_class.new, next_color_class.new).evaluate).to eq(true_value)
         end
       end
     end
 
-    it "evaluates for directions" do
+    it 'evaluates for directions' do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
-        expect(LessThan.new(dir_class.new, dir_class.new).
-          evaluate).to eq(false_value)
+        expect(described_class.new(dir_class.new, dir_class.new).evaluate).to eq(false_value)
         dir_classes.take(index).each do |previous_dir_class|
-          expect(LessThan.new(dir_class.new, previous_dir_class.new).
-            evaluate).to eq(false_value)
+          expect(described_class.new(dir_class.new, previous_dir_class.new).evaluate).to eq(false_value)
         end
-        dir_classes.drop(index+1).each do |next_dir_class|
-          expect(LessThan.new(dir_class.new, next_dir_class.new).
-            evaluate).to eq(true_value)
+        dir_classes.drop(index + 1).each do |next_dir_class|
+          expect(described_class.new(dir_class.new, next_dir_class.new).evaluate).to eq(true_value)
         end
       end
     end
-
   end
 
   describe LessEqual do
-
-    it "evaluates for booleans" do
-      expect(LessEqual.new(false_value, false_value).evaluate).to eq(true_value)
-      expect(LessEqual.new(false_value, true_value).evaluate).to eq(true_value)
-      expect(LessEqual.new(true_value, false_value).evaluate).to eq(false_value)
-      expect(LessEqual.new(true_value, true_value).evaluate).to eq(true_value)
+    it 'evaluates for booleans' do
+      expect(described_class.new(false_value, false_value).evaluate).to eq(true_value)
+      expect(described_class.new(false_value, true_value).evaluate).to eq(true_value)
+      expect(described_class.new(true_value, false_value).evaluate).to eq(false_value)
+      expect(described_class.new(true_value, true_value).evaluate).to eq(true_value)
     end
 
-    it "evaluates for numbers" do
-      expect(LessEqual.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
-      expect(LessEqual.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
-      expect(LessEqual.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
+    it 'evaluates for numbers' do
+      expect(described_class.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
+      expect(described_class.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(false_value)
+      expect(described_class.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
     end
 
-    it "evaluates for colors" do
+    it 'evaluates for colors' do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
-        expect(LessEqual.new(color_class.new, color_class.new).
-          evaluate).to eq(true_value)
+        expect(described_class.new(color_class.new, color_class.new).evaluate).to eq(true_value)
         color_classes.take(index).each do |previous_color_class|
-          expect(LessEqual.new(color_class.new, previous_color_class.new).
-            evaluate).to eq(false_value)
+          expect(described_class.new(color_class.new, previous_color_class.new).evaluate).to eq(false_value)
         end
-        color_classes.drop(index+1).each do |next_color_class|
-          expect(LessEqual.new(color_class.new, next_color_class.new).
-            evaluate).to eq(true_value)
+        color_classes.drop(index + 1).each do |next_color_class|
+          expect(described_class.new(color_class.new, next_color_class.new).evaluate).to eq(true_value)
         end
       end
     end
 
-    it "evaluates for directions" do
+    it 'evaluates for directions' do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
-        expect(LessEqual.new(dir_class.new, dir_class.new).
-          evaluate).to eq(true_value)
+        expect(described_class.new(dir_class.new, dir_class.new).evaluate).to eq(true_value)
         dir_classes.take(index).each do |previous_dir_class|
-          expect(LessEqual.new(dir_class.new, previous_dir_class.new).
-            evaluate).to eq(false_value)
+          expect(described_class.new(dir_class.new, previous_dir_class.new).evaluate).to eq(false_value)
         end
-        dir_classes.drop(index+1).each do |next_dir_class|
-          expect(LessEqual.new(dir_class.new, next_dir_class.new).
-            evaluate).to eq(true_value)
+        dir_classes.drop(index + 1).each do |next_dir_class|
+          expect(described_class.new(dir_class.new, next_dir_class.new).evaluate).to eq(true_value)
         end
       end
     end
-
   end
 
   describe GreaterThan do
-
-    it "evaluates for booleans" do
-      expect(GreaterThan.new(false_value, false_value).evaluate).to eq(false_value)
-      expect(GreaterThan.new(false_value, true_value).evaluate).to eq(false_value)
-      expect(GreaterThan.new(true_value, false_value).evaluate).to eq(true_value)
-      expect(GreaterThan.new(true_value, true_value).evaluate).to eq(false_value)
+    it 'evaluates for booleans' do
+      expect(described_class.new(false_value, false_value).evaluate).to eq(false_value)
+      expect(described_class.new(false_value, true_value).evaluate).to eq(false_value)
+      expect(described_class.new(true_value, false_value).evaluate).to eq(true_value)
+      expect(described_class.new(true_value, true_value).evaluate).to eq(false_value)
     end
 
-    it "evaluates for numbers" do
-      expect(GreaterThan.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
-      expect(GreaterThan.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
-      expect(GreaterThan.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
+    it 'evaluates for numbers' do
+      expect(described_class.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
+      expect(described_class.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
+      expect(described_class.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
     end
 
-    it "evaluates for colors" do
+    it 'evaluates for colors' do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
-        expect(GreaterThan.new(color_class.new, color_class.new).
-          evaluate).to eq(false_value)
+        expect(described_class.new(color_class.new, color_class.new).evaluate).to eq(false_value)
         color_classes.take(index).each do |previous_color_class|
-          expect(GreaterThan.new(color_class.new, previous_color_class.new).
-            evaluate).to eq(true_value)
+          expect(described_class.new(color_class.new, previous_color_class.new).evaluate).to eq(true_value)
         end
-        color_classes.drop(index+1).each do |next_color_class|
-          expect(GreaterThan.new(color_class.new, next_color_class.new).
-            evaluate).to eq(false_value)
+        color_classes.drop(index + 1).each do |next_color_class|
+          expect(described_class.new(color_class.new, next_color_class.new).evaluate).to eq(false_value)
         end
       end
     end
 
-    it "evaluates for directions" do
+    it 'evaluates for directions' do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
-        expect(GreaterThan.new(dir_class.new, dir_class.new).
-          evaluate).to eq(false_value)
+        expect(described_class.new(dir_class.new, dir_class.new).evaluate).to eq(false_value)
         dir_classes.take(index).each do |previous_dir_class|
-          expect(GreaterThan.new(dir_class.new, previous_dir_class.new).
-            evaluate).to eq(true_value)
+          expect(described_class.new(dir_class.new, previous_dir_class.new).evaluate).to eq(true_value)
         end
-        dir_classes.drop(index+1).each do |next_dir_class|
-          expect(GreaterThan.new(dir_class.new, next_dir_class.new).
-            evaluate).to eq(false_value)
+        dir_classes.drop(index + 1).each do |next_dir_class|
+          expect(described_class.new(dir_class.new, next_dir_class.new).evaluate).to eq(false_value)
         end
       end
     end
-
   end
 
   describe GreaterEqual do
-
-    it "evaluates for booleans" do
-      expect(GreaterEqual.new(false_value, false_value).evaluate).to eq(true_value)
-      expect(GreaterEqual.new(false_value, true_value).evaluate).to eq(false_value)
-      expect(GreaterEqual.new(true_value, false_value).evaluate).to eq(true_value)
-      expect(GreaterEqual.new(true_value, true_value).evaluate).to eq(true_value)
+    it 'evaluates for booleans' do
+      expect(described_class.new(false_value, false_value).evaluate).to eq(true_value)
+      expect(described_class.new(false_value, true_value).evaluate).to eq(false_value)
+      expect(described_class.new(true_value, false_value).evaluate).to eq(true_value)
+      expect(described_class.new(true_value, true_value).evaluate).to eq(true_value)
     end
 
-    it "evaluates for numbers" do
-      expect(GreaterEqual.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
-      expect(GreaterEqual.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
-      expect(GreaterEqual.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
+    it 'evaluates for numbers' do
+      expect(described_class.new(15.to_gbs_num, 42.to_gbs_num).evaluate).to eq(false_value)
+      expect(described_class.new(42.to_gbs_num, 15.to_gbs_num).evaluate).to eq(true_value)
+      expect(described_class.new(42.to_gbs_num, 42.to_gbs_num).evaluate).to eq(true_value)
     end
 
-    it "evaluates for colors" do
+    it 'evaluates for colors' do
       color_classes = Color.order
       color_classes.each_with_index do |color_class, index|
-        expect(GreaterEqual.new(color_class.new, color_class.new).
-          evaluate).to eq(true_value)
+        expect(described_class.new(color_class.new, color_class.new).evaluate).to eq(true_value)
         color_classes.take(index).each do |previous_color_class|
-          expect(GreaterEqual.new(color_class.new, previous_color_class.new).
-            evaluate).to eq(true_value)
+          expect(described_class.new(color_class.new, previous_color_class.new).evaluate).to eq(true_value)
         end
-        color_classes.drop(index+1).each do |next_color_class|
-          expect(GreaterEqual.new(color_class.new, next_color_class.new).
-            evaluate).to eq(false_value)
+        color_classes.drop(index + 1).each do |next_color_class|
+          expect(described_class.new(color_class.new, next_color_class.new).evaluate).to eq(false_value)
         end
       end
     end
 
-    it "evaluates for directions" do
+    it 'evaluates for directions' do
       dir_classes = Direction.order
       dir_classes.each_with_index do |dir_class, index|
-        expect(GreaterEqual.new(dir_class.new, dir_class.new).
-          evaluate).to eq(true_value)
+        expect(described_class.new(dir_class.new, dir_class.new).evaluate).to eq(true_value)
         dir_classes.take(index).each do |previous_dir_class|
-          expect(GreaterEqual.new(dir_class.new, previous_dir_class.new).
-            evaluate).to eq(true_value)
+          expect(described_class.new(dir_class.new, previous_dir_class.new).evaluate).to eq(true_value)
         end
-        dir_classes.drop(index+1).each do |next_dir_class|
-          expect(GreaterEqual.new(dir_class.new, next_dir_class.new).
-            evaluate).to eq(false_value)
+        dir_classes.drop(index + 1).each do |next_dir_class|
+          expect(described_class.new(dir_class.new, next_dir_class.new).evaluate).to eq(false_value)
         end
       end
     end
-
   end
-
 end

data/spec/lang/expressions/enclosed_by_parens_expression_spec.rb

@@ -1,11 +1,7 @@
-describe EnclosedByParensExpression do
-
+RSpec.describe EnclosedByParensExpression do
   let(:context) { clean_context }
 
-  it "evaluates the inner expression" do
-    expression = EnclosedByParensExpression.new rojo
-
-    expect(expression.evaluate(context)).to eq(rojo)
+  it 'evaluates the inner expression' do
+    expect(described_class.new(rojo).evaluate(context)).to eq(rojo)
   end
-
 end

data/spec/lang/expressions/function_call_spec.rb

@@ -1,29 +1,33 @@
-describe FunctionCall do
+RSpec.describe FunctionCall do
+  let(:my_function) { Function.new('myFunction', args, empty_body, return_statement) }
+  let(:program) { Program.new([my_function], no_return_statement) }
+  let(:context) { program_context_for(program) }
+  let(:call) { described_class.new('myFunction', calling_arguments) }
 
-  it "evaluates an existing function and returns its result when calling it" do
-    return_statement = ReturnFromFunction.new [42.to_gbs_num]
-    my_function = Function.new 'myFunction', no_arguments, empty_body, return_statement
-    program = Program.new [my_function], no_return_statement
-    context = program_context_for program
-    call = FunctionCall.new 'myFunction', []
+  context 'without arguments' do
+    let(:args) { no_arguments }
+    let(:return_statement) { ReturnFromFunction.new([42.to_gbs_num]) }
+    let(:calling_arguments) { [] }
 
-    result = call.evaluate context
+    it 'evaluates an existing function and returns its result when calling it' do
+      result = call.evaluate(context)
 
-    expect(result).to eq(42.to_gbs_num)
+      expect(result).to eq(42.to_gbs_num)
+    end
   end
 
-  it "evaluates an existing function with some arguments" do
-    number_a, number_b, number_c = 'a'.to_var_name, 'b'.to_var_name, 'c'.to_var_name
-    return_statement = ReturnFromFunction.new [Add.new(Add.new(number_a, number_b), number_c)]
-    args = VarTuple.new [number_a, number_b, number_c]
-    my_function = Function.new 'myFunction', args, empty_body, return_statement
-    program = Program.new [my_function], no_return_statement
-    context = program_context_for program
-    call = FunctionCall.new 'myFunction', [1.to_gbs_num, 2.to_gbs_num, 3.to_gbs_num]
+  context 'with arguments' do
+    let(:number_a) { 'a'.to_var_name }
+    let(:number_b) { 'b'.to_var_name }
+    let(:number_c) { 'c'.to_var_name }
+    let(:args) { VarTuple.new([number_a, number_b, number_c]) }
+    let(:return_statement) { ReturnFromFunction.new([Add.new(Add.new(number_a, number_b), number_c)]) }
+    let(:calling_arguments) { [1.to_gbs_num, 2.to_gbs_num, 3.to_gbs_num] }
 
-    result = call.evaluate context
+    it 'evaluates an existing function with some arguments' do
+      result = call.evaluate(context)
 
-    expect(result).to eq(6.to_gbs_num)
+      expect(result).to eq(6.to_gbs_num)
+    end
   end
-
 end