trxl 0.1.5

data/spec/trxl/comments_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "For commenting, the language" do
+  
+  include Trxl::SpecHelper
+  
+  before :each do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should allow single line comments" do
+    eval("# This is only a comment").should be_nil
+    eval("# This is only a comment\n").should be_nil
+    eval("# This is only a comment a = 5; a;").should be_nil
+    eval("a = 5 # This is only a comment").should == 5
+    eval("a = 5 # This is only a comment\n").should == 5
+    eval("a = 5; # This is only a comment").should == 5
+    eval("a = 5; # This is only a comment\n").should == 5
+  end
+
+  it "should allow multi line comments" do
+    eval("/* This is a multiline comment */ a = 5; a;").should == 5
+    eval("a = 5; /* This is a multiline comment */ a;").should == 5
+
+    program = <<-PROGRAM
+      a = 1;
+      /*
+       * This is a multiline comment
+       */
+      a * 2;
+    PROGRAM
+    eval(program).should == 2
+  end
+  
+end

data/spec/trxl/common_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "The parser" do
+  
+  include Trxl::SpecHelper
+  
+  before :each do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should return NULL for an empty string" do
+    program =  ""
+    eval(program).should == nil
+  end
+    
+  it "should ignore multiple ';' characters (like ;;;)" do
+    eval(";").should == nil
+    eval(";;").should == nil
+    eval("1+1;;").should == 2
+  end
+  
+end

data/spec/trxl/conditionals_spec.rb

@@ -0,0 +1,454 @@
+require 'spec_helper'
+
+describe "For conditional evaluation, the language" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should be able to evaluate conditional 'if' expressions without elsif and else branches" do
+    program =  "test = fun(x) { if(x) TRUE end };"
+    eval(program + "test(TRUE)").should be_true
+    eval(program + "test(FALSE)").should be_nil
+  end
+
+  it "should be able to evaluate conditional 'if' expressions with only an else branch" do
+    program = <<-PROGRAM
+      if(TRUE)
+        TRUE
+      else
+        FALSE
+      end
+    PROGRAM
+    eval(program).should be_true
+    
+    program = <<-PROGRAM
+      if(FALSE)
+        TRUE
+      else
+        FALSE
+      end
+    PROGRAM
+    eval(program).should be_false
+    
+    program = <<-PROGRAM
+      if(NULL)
+        TRUE
+      else
+        FALSE
+      end
+    PROGRAM
+    eval(program).should be_false
+    
+    program = <<-PROGRAM
+      if(NULL != NULL)
+        TRUE
+      else
+        FALSE
+      end
+    PROGRAM
+    eval(program).should be_false
+  end
+
+  it "should be able to evaluate nested 'if' expressions" do
+    program = <<-PROGRAM
+      if(TRUE)
+        if(TRUE)
+          TRUE
+        else
+          FALSE
+        end
+      else
+        FALSE
+      end
+    PROGRAM
+    eval(program).should be_true
+
+    program = <<-PROGRAM
+      x = 1;
+      if(TRUE)
+        if(TRUE)
+          x
+        else
+          FALSE
+        end
+      else
+        FALSE
+      end
+    PROGRAM
+    eval(program).should == 1
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(TRUE)
+        if(TRUE)
+          TRUE
+        else
+          FALSE
+        end
+      else
+        FALSE
+      end
+    };
+    foo()
+    PROGRAM
+    eval(program).should be_true
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(TRUE)
+        if(TRUE)
+          "if branch"
+        else
+          FALSE
+        end
+      elsif(2 == 3)
+        FALSE
+      elsif(2 == 4)
+        FALSE
+      else
+        FALSE
+      end
+    };
+    foo()
+    PROGRAM
+    eval(program).should == "if branch"
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(FALSE)
+        if(TRUE)
+          TRUE
+        else
+          FALSE
+        end
+      elsif(TRUE)
+        if(TRUE)
+          "first elsif branch"
+        else
+          FALSE
+        end
+      elsif(2 == 4)
+        FALSE
+      else
+        FALSE
+      end
+    };
+    foo()
+    PROGRAM
+    eval(program).should == "first elsif branch"
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(FALSE)
+        if(TRUE)
+          TRUE
+        else
+          FALSE
+        end
+      elsif(FALSE)
+        if(TRUE)
+          "first elsif branch"
+        else
+          FALSE
+        end
+      elsif(TRUE)
+         if(TRUE)
+          "second elsif branch"
+        else
+          FALSE
+        end
+      else
+        FALSE
+      end
+    };
+    foo()
+    PROGRAM
+    eval(program).should == "second elsif branch"
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(FALSE)
+        if(TRUE)
+          TRUE
+        else
+          FALSE
+        end
+      elsif(FALSE)
+        if(TRUE)
+          "first elsif branch"
+        else
+          FALSE
+        end
+      elsif(FALSE)
+        if(TRUE)
+          "second elsif branch"
+        else
+          FALSE
+        end
+      else
+        if(TRUE)
+          "else branch"
+        else
+          FALSE
+        end
+      end
+    };
+    foo()
+    PROGRAM
+    eval(program).should == "else branch"
+  end
+  
+  it "should be able to evaluate conditional 'if' expressions with multiple elsif and an else branch" do
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 2)
+        0
+      elsif(2 == 3)
+        1
+      elsif(2 == 4)
+        2
+      else
+        3
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 0
+    
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 1)
+        0
+      elsif(2 == 2)
+        1
+      elsif(2 == 3)
+        2
+      else
+        3
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 1
+    
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 0)
+        0
+      elsif(2 == 1)
+        1
+      elsif(2 == 2)
+        2
+      else
+        3
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 2
+    
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 0)
+        0
+      elsif(2 == 1)
+        1
+      elsif(2 == 3)
+        2
+      else
+        3
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 3
+    
+    program = <<-PROGRAM
+    foo = fun(value) {
+      if(value <=  5000)
+        22.02
+      elsif(value <= 12000)
+        18.75
+      elsif(value <= 25000)
+        15.92
+      elsif(value <= 50000)
+        12.72
+      elsif(value >  50000)
+        10.32
+      else
+        NULL
+      end
+    };
+    foo(13000);
+    PROGRAM
+    eval(program).should == 15.92 
+  end
+  
+  it "should allow an arbitrary number of statements inside if/elsif/else expressions" do
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 2)
+        a = 0;
+        a
+      elsif(2 == 1)
+        b = 1;
+        b
+      elsif(2 == 3)
+        c = 2;
+        c
+      else
+        d = 3;
+        d
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 0   
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 0)
+        a = 0;
+        a
+      elsif(2 == 2)
+        b = 1;
+        b
+      elsif(2 == 3)
+        c = 2;
+        c
+      else
+        d = 3;
+        d
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 1   
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 0)
+        a = 0;
+        a
+      elsif(2 == 1)
+        b = 1;
+        b
+      elsif(2 == 2)
+        c = 2;
+        c
+      else
+        d = 3;
+        d
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 2   
+
+    program = <<-PROGRAM
+    foo = fun() {
+      if(2 == 0)
+        a = 0;
+        a
+      elsif(2 == 1)
+        b = 1;
+        b
+      elsif(2 == 3)
+        c = 2;
+        c
+      else
+        d = 3;
+        d
+      end
+    };
+    foo();
+    PROGRAM
+    eval(program).should == 3  
+  end
+  
+  it "should allow arbitrary expressions as conditional expression" do
+    program =  "test = fun(x) {if(x == 0) TRUE else FALSE end};"
+    program << "test(0)"
+    eval(program).should be_true
+    program =  "test = fun(x) {if(2*2 == 4) TRUE else FALSE end};"
+    program << "test(0)"
+    eval(program).should be_true
+    program =  "test = fun(x) {if(TRUE) TRUE else FALSE end};"
+    program << "test(0)"
+    eval(program).should be_true
+    program =  "test = fun(x) {if(x) TRUE else FALSE end};"
+    program << "test(TRUE)"
+    eval(program).should be_true
+    program =  "test = fun(x) {if(x) TRUE else FALSE end};"
+    program << "test(FALSE)"
+    eval(program).should be_false
+    program =  "x = TRUE;"
+    program << "test = fun(x) {if(x) TRUE else FALSE end};"
+    program << "test(x)"
+    eval(program).should be_true
+    program =  "x = (4 == 4);"
+    program << "test = fun(x) {if(x) TRUE else FALSE end};"
+    program << "test(x)"
+    eval(program).should be_true
+  end
+
+  it "should allow 'case' expressions with multiple 'when' and one 'else' branch" do
+    program = <<-PROGRAM
+    foo = fun(x) {
+      case x
+        when 1 then "one"
+        when 2 then "two"
+        when 3 then "three"
+        else FALSE
+      end
+    };
+    foo(2);
+    PROGRAM
+    eval(program).should == "two"
+
+    program = <<-PROGRAM
+    foo = fun(x) {
+      case x
+        when "foo" then "yes"
+        when "bar" then "no"
+        else FALSE
+      end
+    };
+    foo("foo");
+    PROGRAM
+    eval(program).should == "yes"
+
+    program = <<-PROGRAM
+    foo = fun(x) {
+      case x
+        when "foo" then "yes"
+        when "bar" then "no"
+        else "something else"
+      end
+    };
+    foo("hello");
+    PROGRAM
+    eval(program).should == "something else"
+  end
+
+  it "should allow multiple statements in each branch of a 'case' expression" do
+    program = <<-PROGRAM
+    foo = fun(x) {
+      num = 0;
+      name = case x
+        when 1 then num = num + 1; "one"
+        when 2 then num = num + 2; "two"
+        when 3 then num = num + 3; "three"
+        else FALSE
+      end;
+      [ num, name ]
+    };
+    foo(1);
+    PROGRAM
+    eval(program).should == [ 1, "one" ]
+  end
+  
+end