crisp 0.0.5 → 0.0.7

data/lib/crisp/parser.rb

@@ -1,11 +1,18 @@
 module Crisp
+  # The Crisp parser
+  #
+  # The parser uses treetop for defining the syntax (see crisp.treetop)
+  # For parsing crisp code (as string) call parse on a instance.
+  # The output of the parser can be evaluated by passing it to a Crisp runtime.
   class Parser
     Treetop.load(File.expand_path(File.join(File.dirname(__FILE__), 'crisp.treetop')))
 
+    # create a new treetop parser
     def initialize
       @parser = CrispParser.new
     end
 
+    # parse the code and return an abstract syntax tree (ast)
     def parse(code)
       ast = @parser.parse(code)
 

data/lib/crisp/runtime.rb

@@ -1,10 +1,17 @@
 module Crisp
+  # The Crisp Runtime
+  #
+  # Each runtime holds its own environment.
+  # All predefined functions are loaded when creating a new runtime.
+  # Run code by calling run with the output of the parser as argurment.
   class Runtime
+    # create a new env and load all functions when creating a new runtime
     def initialize
       @env = Env.new
       Functions.load(@env)
     end
 
+    # run the parsed code (abstract syntax tree)
     def run(ast)
       ast.eval(@env)
     end

data/lib/crisp/shell.rb

@@ -1,7 +1,11 @@
 module Crisp
+  # The Crisp interactive shell
+  #
+  # Create a new instance and call run for having a interactive Crisp shell.
   class Shell
     require 'readline'
 
+    # start the shell
     def run
       runtime = Runtime.new
       buffer = ''

data/spec/crisp/arithmetics_spec.rb

@@ -1,67 +1,95 @@
 require 'spec_helper'
 
-describe "when evaluating arithmetic expressions, the language" do
+describe "arithemtic functions" do
   include Crisp::SpecHelper
 
-  it "should calculate integer addition" do
+  it "adds integer values" do
     evaluate("(+ 1 2)").should == 3
     evaluate("(+ 12 13 1 5)").should == 31
     evaluate("(+ 12 13 -1 -5)").should == 19
   end
 
-  it "should calculate integer substraction" do
+  it "substracts integer values" do
     evaluate("(- 3 1)").should == 2
     evaluate("(- 14 1 4 8)").should == 1
     evaluate("(- 2 5)").should == -3
     evaluate("(- 2 -5)").should == 7
   end
 
-  it "should calculate integer multiplications" do
+  it "multiplies integer values" do
     evaluate("(* 2 3)").should == 6
     evaluate("(* 0 3)").should == 0
     evaluate("(* 2 -3 1 10)").should == -60
   end
 
-  it "should calculate integer divisions" do
+  it "divides integer values" do
     evaluate("(/ 12 3)").should == 4
     evaluate("(/ 48 2 12)").should == 2
     evaluate("(/ 30 -3 2)").should == -5
   end
 
-  it "should calculate nested arithmetic integer expressions" do
+  it "calculates different nested operations" do
     evaluate("(+ 1 2 (+ 2 3) (- 5 1)) ").should == 12
     evaluate("(+ 1 2 (* 2 3) (/ 10 2)) ").should == 14
     evaluate("(+ 1 2 (- 10 2 3) (* 1 2 3) (/ 12 4)) ").should == 17
     evaluate("(/ 20 2 (+ 2 3) (- 5 3)) ").should == 1
   end
 
-  it "should calculate float addition" do
+  it "adds float values" do
     evaluate("(+ 1.0 2.)").should == 3.0
     evaluate("(+ 12.5 13 1.4 5)").should == 31.9
     evaluate("(+ 12. 13.5 -1.9 -5.1)").should == 18.5
   end
 
-  it "should calculate float substraction" do
+  it "substracts float values" do
     evaluate("(- 3. 1.4)").should == 1.6
     evaluate("(- 2 5.5)").should == -3.5
     evaluate("(- 2.40 -5)").should == 7.4
   end
 
-  it "should calculate float multiplications" do
+  it "multiplies float values" do
     evaluate("(* 2.1 3.4)").should == 7.14
     evaluate("(* 0 3.5)").should == 0
     evaluate("(* 2 -3.1 1.9 10.1)").should == -118.978
   end
 
-  it "should calculate float divisions" do
+  it "divides float values" do
     evaluate("(/ 12.5 3.1)").should be_within(0.0000001).of(4.03225806451613)
     evaluate("(/ 48 2.000 12.5)").should == 1.92
     evaluate("(/ 30.0 -3 2.5)").should == -4.0
   end
 
-  it "should calculate nested arithmetic float expressions" do
+  it "calculates different nested operations" do
     evaluate("(+ 1 2.3 (* 2 3.5) (/ 10 4)) ").should == 12.3
     evaluate("(+ 1.5 2 (- 10 2.4 3) (* 1.0 2 3) (/ 12 3.0)) ").should == 18.1
     evaluate("(/ 20.4 2 (+ 2.5 3) (- 5.5 3)) ").should be_within(0.000000001).of(0.741818181818182)
   end
+
+  it "compares values for equality" do
+    evaluate("(= 1 1)").should == true
+    evaluate("(= 1 2)").should == false
+  end
+
+  it "compares values that are greater than others" do
+    evaluate("(> 2 1)").should == true
+    evaluate("(> 1 1)").should == false
+    evaluate("(> 1 2)").should == false
+  end
+
+  it "compares values that are less than others" do
+    evaluate("(< 2 1)").should == false
+    evaluate("(< 1 1)").should == false
+    evaluate("(< 1 2)").should == true
+  end
+
+  it "should calc fibonacci numbers" do
+    evaluate("
+      (def fib (
+        fn [n]
+        (if (< n 2)
+          n
+          (+ (fib (- n 1)) (fib (- n 2))))))
+      (fib 10)
+    ").should == 55
+  end
 end

data/spec/crisp/basic_spec.rb

@@ -3,90 +3,25 @@ require 'spec_helper'
 describe "the language" do
   include Crisp::SpecHelper
 
-  it "should not bother whitespaces, tabs and linebreaks in statements" do
+  it "does not bother whitspaces characters in expressions" do
     evaluate(" \r\t\n (\r+\t 1\n2 \t(\n - 9\r\t  \n   2)\r)\r\t   ").should == 10
   end
 
-  it "should print results" do
-    evaluate("(println (+ 1 1))")
-  end
-
-  it "should bind value to symbol" do
-    evaluate("(def bla 3)")
-  end
-
-  it "should not bind value to already binded symbol" do
-    lambda do
-      evaluate("(def name 123)(def name 123)")
-    end.should raise_error(Crisp::EnvironmentError, "name already binded")
-  end
-
-  it "should raise error if use def with wrong args" do
-    lambda do
-      evaluate("(def bla 1 2)")
-    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'def' (3 for 2)")
-  end
-
-  it "should evaluate a list of operations" do
-    lambda do
-      evaluate("(+ 1 2) (def foo 1) (def foo 2)")
-    end.should raise_error(Crisp::EnvironmentError, "foo already binded")
-  end
-
-  it "should produce syntax error on invalid syntax" do
+  it "creates syntax error on invalid expressions" do
     lambda do
       evaluate("(()")
     end.should raise_error(Crisp::SyntaxError, "syntax error at : 0")
   end
 
-  it "should use values of binded symbols in later statements" do
-    evaluate("(def bla 2) (* 4 bla)").should == 8
-    evaluate("(def bla (* 2 3)) (* 4 bla 2)").should == 48
-  end
-
-  it "should parse an array" do
+  it "bind arrays to symbols" do
     evaluate("(def bla [1 2 3])").size.should == 3
     evaluate("(def bla [1 2 3])")[1].should == 2
-    evaluate("(def bla [1 2 foo])")[2].should == :foo
+    evaluate("(def foo 5)(def bla [1 2 foo])")[2].should == 5
   end
 
-  it "should raise error if not providing right amount of parameters for function creation" do
+  it "does not evaluate numbers" do
     lambda do
-      evaluate("(fn [] (+ 1 2) [])")
-    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'fn' (3 for 2)")
-  end
-
-  it "should raise error if not providing proper argument list for function generation" do
-    lambda do
-      evaluate("(fn (+ 2 1) (+ 1 2))")
-    end.should raise_error(Crisp::ArgumentError, "no parameter list defined")
-  end
-
-  it "should raise error if not providing proper function body" do
-    lambda do
-      evaluate("(fn [] [])")
-    end.should raise_error(Crisp::ArgumentError, "no function body defined")
-  end
-
-  it "should create functions" do
-    evaluate("(fn [arg] (+ 2 arg))")
-  end
-
-  it "should bind functions to symbols" do
-    evaluate("(def myfn (fn [arg] (+ 1 arg)))").class.name.should == "Crisp::Function"
-  end
-
-  it "should call functions" do
-    evaluate("(def myfn (fn [a b] (+ 1 1)))(myfn 1 2)").should == 2
-  end
-
-  it "should use parameters when calling functions" do
-    evaluate("(def myfn (fn [a b] (+ a b)))(myfn 5 2)").should == 7
-  end
-
-  it "should raise error on wrong amount of parameters" do
-    lambda do
-      evaluate("(def myfn (fn [a1 a2 a3] (+ 1 1)))(myfn 1)")
-    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'myfn' (1 for 3)")
+      evaluate("(3)")
+    end.should raise_error(Crisp::SyntaxError, "syntax error at : 0")
   end
 end

data/spec/crisp/core_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "the core language features" do
+  include Crisp::SpecHelper
+
+  it "prints results" do
+    evaluate("(println (+ 1 1))")
+  end
+
+  it "binds values to symbols" do
+    evaluate("(def bla 3)")
+  end
+
+  it "does not allow to bind symbols twice" do
+    lambda do
+      evaluate("(def name 123)(def name 123)")
+    end.should raise_error(Crisp::EnvironmentError, "name already binded")
+  end
+
+  it "produces an error when calling bind function with arguments" do
+    lambda do
+      evaluate("(def bla 1 2)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'def' (3 for 2)")
+  end
+
+  it "uses binded values in later expressions" do
+    evaluate("(def bla 2) (* 4 bla)").should == 8
+    evaluate("(def bla (* 2 3)) (* 4 bla 2)").should == 48
+  end
+
+  it "can not resolve unbound symbols" do
+    lambda do
+      evaluate("n")
+    end.should raise_error(Crisp::EnvironmentError, "n is unbound")
+  end
+
+  it "can resolve primitve types" do
+    evaluate("2").should == 2
+    evaluate("2.1").should == 2.1
+    evaluate("nil").should == nil
+    evaluate("true").should == true
+    evaluate("false").should == false
+    evaluate('"abc"').should == 'abc'
+    evaluate("[1 2 3]").should == [1, 2, 3]
+  end
+
+  it "can resolve bounded symbols" do
+    evaluate("(def foo 23) foo").should == 23
+    evaluate('(def foo "foo") foo').should == 'foo'
+  end
+
+  it "binds symbols to value of already bound symbol" do
+    evaluate("(def a 1)
+              (def b a)
+              b").should == 1
+  end
+
+  it "has if statements" do
+    evaluate("(if true 1)").should == 1
+    evaluate("(if false 1)").should == nil
+    evaluate("(if nil 1)").should == nil
+  end
+
+  it "has if else statements" do
+    evaluate("(if true 1 2)").should == 1
+    evaluate("(if false 1 2)").should == 2
+    evaluate("(if nil 1 2)").should == 2
+  end
+
+  it "does not run if statements with wrong number of arguments" do
+    lambda do
+      evaluate("(if true true false 2)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'if' (4 for 2..3)")
+
+    lambda do
+      evaluate("(if true)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'if' (1 for 2..3)")
+  end
+
+  it "resolves symbols in if statements" do
+    evaluate("(def foo 2)(if true foo)").should == 2
+  end
+end

data/spec/crisp/function_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "the languages functions" do
+  include Crisp::SpecHelper
+
+  it "does not create a function when providing wrong number of arguments" do
+    lambda do
+      evaluate("(fn [] (+ 1 2) [])")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'fn' (3 for 2)")
+  end
+
+  it "does not create a function when not providing a proper argument list" do
+    lambda do
+      evaluate("(fn (+ 2 1) (+ 1 2))")
+    end.should raise_error(Crisp::ArgumentError, "no argument list defined")
+  end
+
+  it "does not create a function when not providing a proper function body" do
+    lambda do
+      evaluate("(fn [] [])")
+    end.should raise_error(Crisp::ArgumentError, "no function body defined")
+  end
+
+  it "creates functions" do
+    evaluate("(fn [arg] (+ 2 arg))")
+  end
+
+  it "binds functions to symbols" do
+    evaluate("(def myfn (fn [arg] (+ 1 arg)))").class.name.should == "Crisp::Function"
+  end
+
+  it "calls functions" do
+    evaluate("(def myfn (fn [a b] (+ 1 1)))(myfn 1 2)").should == 2
+  end
+
+  it "calls functions with arguments" do
+    evaluate("(def myfn (fn [a b] (+ a b)))(myfn 5 2)").should == 7
+  end
+
+  it "does not calls functions with wrong number of arguments" do
+    lambda do
+      evaluate("(def myfn (fn [a1 a2 a3] (+ 1 1)))(myfn 1)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'myfn' (1 for 3)")
+  end
+
+  it "instantly evaluates a function" do
+    evaluate("((fn [] (+ 1 2)))").should == 3
+  end
+end

data/spec/crisp/internal_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "internals" do
+  include Crisp::SpecHelper
+
+  it "sets and gets values to and from the env" do
+    env = Crisp::Env.new
+    env['key'] = 'value'
+
+    env['key'].should == 'value'
+    env[:key].should == 'value'
+    env.has_key?('key').should == true
+    env.has_key?(:key).should == true
+  end
+
+  it "handles mismatched env reads" do
+    env = Crisp::Env.new
+
+    env.has_key?('not_exists').should == false
+    env['not_exists'].should == nil
+  end
+
+  it "is not allowed to set env keys twice" do
+    env = Crisp::Env.new
+    env['key'] = 'value'
+
+    lambda do
+      env['key'] = 'another value'
+    end.should raise_error(Crisp::EnvironmentError, "key already binded")
+  end
+
+  it "gets values from a chained env" do
+    env1 = Crisp::Env.new
+    env1[:key1] = 'val1'
+    env1[:key2] = 'val2'
+
+    env2 = Crisp::Env.new
+    env2[:key1] = 'val3'
+    env2[:key3] = 'val4'
+
+    chained = Crisp::ChainedEnv.new(env1, env2)
+
+    chained[:key1].should == 'val1'
+    chained[:key2].should == 'val2'
+    chained[:key3].should == 'val4'
+  end
+
+  it "sets values to a chained env" do
+    env1 = Crisp::Env.new
+    env1[:key] = 'val'
+
+    env2 = Crisp::Env.new
+
+    chained = Crisp::ChainedEnv.new(env1, env2)
+
+    chained[:key] = 'other'
+    env2[:key].should == 'other'
+    chained[:key].should == 'val'
+  end
+end