crisp 0.0.8 → 0.1.0

data/CHANGELOG.md

@@ -1,6 +1,8 @@
-## 0.0.9 (2011-xx-xx)
+## 0.1.0 (2011-04-27)
 
-* ...
+* head/tail functions for array operations
+* more examples
+* alias function
 
 ## 0.0.8 (2011-01-06)
 

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+gemspec
+
+gem 'rake'
+gem 'jeweler'

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    crisp (0.1.0)
+      crisp
+      jeweler
+      rake
+      treetop (~> 1.4.9)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    polyglot (0.3.1)
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  crisp!
+  jeweler
+  rake
+  rspec (~> 2.5.0)

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2010 Markus Gerdes
+Copyright (c) 2010-2011 Markus Gerdes
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,4 +1,4 @@
-## Crisp
+# Crisp
 
 Crisp is an experimental language written in Ruby, using treetop.
 
@@ -6,25 +6,52 @@ Crisp has a Lisp syntax and immutable data structures.
 
 The main purpose of the language is to deal with the issues and problems when creating your own programming language.
 
-### Example
+## Language features
+
+ *   binding values to a symbol with **def**
+ *   calculations with **+**, **-**, __*__ and __/__
+ *   comparisons with **>**, **<** and **=**
+ *   conditional statements with **if**
+ *   loop statements with **loop**/**recur**
+ *   console output with **println**
+ *   function creation with **fn**
+ *   switch/case conditions with **cond**
+ *   local binding with **let**
+ *   dynamic loading of crisp source files with **load**
+ *   head and tail functions for array with **head** and **tail**
+ *   calling native ruby with **.**
+
+## Example
 
         # crisp
-        >> (* 2 3)
-        => 6
-        >> (def foo 4)
-        => 4
-        >> (/ (* foo foo) 2 2)
-        => 4
-        >> (def add2 (fn [arg] (+ 2 arg)))
-        => #<Crisp::Function:0x85d1bc0>
-        >> (add2 5)
-        => 7
-
-### Installation
+        >> (println "Hello World")
+        Hello World
+        =>
+        >> (def fib (
+        ?>   fn [n]
+        ?>     (if (< n 2)
+        ?>       n
+        ?>         (+ (fib (- n 1)) (fib (- n i))))))
+        => #<Crisp::Function:0x1005c2500>
+        >> (fib 10)
+        => 55
+        >> (def factorial
+        ?>   (fn [n]
+        ?>     (loop [cnt n acc 1]
+        ?>       (if (= 0 cnt)
+        ?>         acc
+        ?>         (recur (- cnt 1) (* acc cnt))))))
+        => #<Crisp::Function:0x1001ad9d8>
+        >> (factorial 12)
+        => 479001600
+
+For more examples see the examples directory in the repository.
+
+## Installation
 
         gem install crisp
 
-### Usage
+## Usage
 
 To start an interactive shell:
         crisp

data/Rakefile

@@ -15,7 +15,7 @@ begin
     gem.homepage = "http://github.com/mgsnova/crisp"
     gem.authors = ['Markus Gerdes']
     gem.add_dependency 'treetop', '~> 1.4.9'
-    gem.add_development_dependency 'rspec', '~> 2.4.0'
+    gem.add_development_dependency 'rspec', '~> 2.5.0'
   end
 
   Jeweler::GemcutterTasks.new

data/bin/crisp

@@ -6,7 +6,7 @@ if ARGV.size == 0
   Crisp::Shell.new.run
 elsif ARGV.size == 1
   ast = Crisp::Parser.new.parse(File.read(ARGV[0]))
-  Crisp::Runtime.new.run(ast).to_s
+  Crisp::Runtime.new.run(ast)
 else
   puts "to many args"
   exit 1

data/crisp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{crisp}
-  s.version = "0.0.8"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Markus Gerdes"]
-  s.date = %q{2011-01-06}
+  s.date = %q{2011-04-27}
   s.default_executable = %q{crisp}
   s.email = %q{github@mgsnova.de}
   s.executables = ["crisp"]
@@ -19,12 +19,17 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     "CHANGELOG.md",
+    "Gemfile",
+    "Gemfile.lock",
     "LICENSE",
     "README.md",
     "Rakefile",
     "autotest/discover.rb",
     "bin/crisp",
     "crisp.gemspec",
+    "examples/array.crisp",
+    "examples/calculation.crisp",
+    "examples/comparisons.crisp",
     "examples/factorial.crisp",
     "examples/fibonacci.crisp",
     "examples/run.crisp",
@@ -37,6 +42,7 @@ Gem::Specification.new do |s|
     "lib/crisp/function_runner.rb",
     "lib/crisp/functions.rb",
     "lib/crisp/functions/arithmetic.rb",
+    "lib/crisp/functions/array.rb",
     "lib/crisp/functions/core.rb",
     "lib/crisp/native_call_invoker.rb",
     "lib/crisp/nodes.rb",
@@ -56,6 +62,7 @@ Gem::Specification.new do |s|
     "lib/crisp/runtime.rb",
     "lib/crisp/shell.rb",
     "spec/crisp/arithmetics_spec.rb",
+    "spec/crisp/array_spec.rb",
     "spec/crisp/basic_spec.rb",
     "spec/crisp/core_spec.rb",
     "spec/crisp/function_spec.rb",
@@ -70,6 +77,7 @@ Gem::Specification.new do |s|
   s.summary = %q{a tiny lisp-like language written in ruby using treetop.}
   s.test_files = [
     "spec/crisp/arithmetics_spec.rb",
+    "spec/crisp/array_spec.rb",
     "spec/crisp/basic_spec.rb",
     "spec/crisp/core_spec.rb",
     "spec/crisp/function_spec.rb",
@@ -84,15 +92,27 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<crisp>, [">= 0"])
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_runtime_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.5.0"])
       s.add_runtime_dependency(%q<treetop>, ["~> 1.4.9"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.4.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.5.0"])
     else
+      s.add_dependency(%q<crisp>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.5.0"])
       s.add_dependency(%q<treetop>, ["~> 1.4.9"])
-      s.add_dependency(%q<rspec>, ["~> 2.4.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.5.0"])
     end
   else
+    s.add_dependency(%q<crisp>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.5.0"])
     s.add_dependency(%q<treetop>, ["~> 1.4.9"])
-    s.add_dependency(%q<rspec>, ["~> 2.4.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.5.0"])
   end
 end
 

data/examples/array.crisp

@@ -0,0 +1,3 @@
+(println "head of [1,2,3] is " (head [1 2 3]))
+
+(println "tail of [1,2,3] is " (tail [1 2 3]))

data/examples/calculation.crisp

@@ -0,0 +1,7 @@
+(println "1 plus 1 is " (+ 1 1))
+
+(println "3 minus 2 is " (- 3 2))
+
+(println "2 multiplied with 3 is " (* 2 3))
+
+(println "8 divided by 2 is " (/ 8 2))

data/examples/comparisons.crisp

@@ -0,0 +1,18 @@
+(if (= 2 2)
+  (println "2 equals 2"))
+
+(if (= 2 1)
+  (println "2 equals 1")
+  (println "2 does not equals 1"))
+
+(cond
+  (> 2 1) (println "2 is greater than 1"))
+
+(cond
+  (> 1 2) (println "1 is greater than 2")
+  (< 1 2) (println "1 is less than 2"))
+
+(cond
+  (> 1 1) (println "1 is greater than 1")
+  (< 1 1) (println "1 is less then 1")
+  else (println "1 is probably equal 1"))

data/examples/run.crisp

@@ -1,5 +1,8 @@
 (load "fibonacci")
 (load "factorial")
+(load "comparisons")
+(load "calculation")
+(load "array")
 
 (println "fibonacci for 10 is" (fib 10))
 (println "factorial of 10 is" (factorial 10))

data/lib/crisp.rb

@@ -3,7 +3,7 @@ require "treetop"
 require "pp"
 
 module Crisp
-  VERSION = '0.0.8'
+  VERSION = '0.1.0'
 end
 
 require 'crisp/errors'

data/lib/crisp/chained_env.rb

@@ -39,5 +39,10 @@ module Crisp
     def global_loop_data=(data)
       @second.global_loop_data = data
     end
+
+    # set alias to global/second env
+    def alias(to, from)
+      @second.alias(to, from)
+    end
   end
 end

data/lib/crisp/env.rb

@@ -16,7 +16,13 @@ module Crisp
 
     # Returns the value for the given key.
     def [](key)
-      @map[key.to_sym]
+      result = @map[key.to_sym]
+
+      if result.class == Hash and result[:alias_to]
+        self[result[:alias_to]]
+      else
+        result
+      end
     end
 
     # Store the key/value pair.
@@ -26,5 +32,10 @@ module Crisp
       raise EnvironmentError, "#{key} already binded" if @map.has_key?(key)
       @map[key] = val
     end
+
+    # Store alias
+    def alias(to, from)
+      self[to] = {:alias_to => from}
+    end
   end
 end

data/lib/crisp/functions.rb

@@ -3,11 +3,13 @@ module Crisp
     # require all files that are defining functions
     require 'crisp/functions/core'
     require 'crisp/functions/arithmetic'
+    require 'crisp/functions/array'
 
     # Load all defined function to the given environment
     def self.load(env)
       Core.load(env)
       Arithmetic.load(env)
+      Array.load(env)
     end
   end
 end

data/lib/crisp/functions/array.rb

@@ -0,0 +1,49 @@
+module Crisp
+  module Functions
+    # Defining array crisp functions
+    class Array
+      # load the functions and bind them into the given environment
+      def self.load(current_env)
+
+        # head
+        # return head of array
+        #
+        #  (head [1 2 3])
+        #  => 1
+        Function.new do
+          validate_args_count(1, args.size)
+
+          if args[0].class.name != "Crisp::Nodes::ArrayLiteral"
+            raise ArgumentError, "argument is not an array"
+          end
+
+          if raw_head = args[0].raw_elements[0]
+            raw_head.resolve(env)
+          else
+            nil
+          end
+        end.bind('head', current_env)
+
+        # tail
+        # return tail of array
+        #
+        #  (tail [1 2 3])
+        #  => [2 3]
+        Function.new do
+          validate_args_count(1, args.size)
+
+          if args[0].class.name != "Crisp::Nodes::ArrayLiteral"
+            raise ArgumentError, "argument is not an array"
+          end
+
+          if raw_tail = args[0].raw_elements[1..-1]
+            raw_tail.map { |arg| arg.resolve(env) }
+          else
+            []
+          end
+        end.bind('tail', current_env)
+
+      end
+    end
+  end
+end

data/lib/crisp/functions/core.rb

@@ -256,6 +256,21 @@ module Crisp
           true
         end.bind('load', current_env)
 
+        # alias
+        # create alias from one symbol to another
+        # 
+        #  (alias p println)
+        #  (p 123)
+        #  123 
+        Function.new do
+          validate_args_count(2, args.size)
+
+          to = args[0].text_value
+          from = args[1].text_value
+
+          env.alias(to, from)
+        end.bind('alias', current_env)
+
       end
     end
   end

data/spec/crisp/arithmetics_spec.rb

@@ -3,86 +3,86 @@ require 'spec_helper'
 describe "arithemtic functions" do
   include Crisp::SpecHelper
 
-  it "adds integer values" do
+  it "should add integer values" do
     evaluate("(+ 1 2)").should == 3
     evaluate("(+ 12 13 1 5)").should == 31
     evaluate("(+ 12 13 -1 -5)").should == 19
   end
 
-  it "substracts integer values" do
+  it "should substract 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 "multiplies integer values" do
+  it "should multiply integer values" do
     evaluate("(* 2 3)").should == 6
     evaluate("(* 0 3)").should == 0
     evaluate("(* 2 -3 1 10)").should == -60
   end
 
-  it "divides integer values" do
+  it "should divide integer values" do
     evaluate("(/ 12 3)").should == 4
     evaluate("(/ 48 2 12)").should == 2
     evaluate("(/ 30 -3 2)").should == -5
   end
 
-  it "calculates different nested operations" do
+  it "should calculate 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 "adds float values" do
+  it "should add 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 "substracts float values" do
+  it "should substract 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 "multiplies float values" do
+  it "should multiply 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 "divides float values" do
+  it "should divide 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 "calculates different nested operations" do
+  it "should calculate 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
+  it "should compare values for equality" do
     evaluate("(= 1 1)").should == true
     evaluate("(= 1 2)").should == false
   end
 
-  it "compares values that are greater than others" do
+  it "should compare 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
+  it "should compare values that are less than others" do
     evaluate("(< 2 1)").should == false
     evaluate("(< 1 1)").should == false
     evaluate("(< 1 2)").should == true
   end
 
-  it "calculates fibonacci numbers" do
+  it "should calculate fibonacci numbers" do
     evaluate("
       (def fib (
         fn [n]

data/spec/crisp/array_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "the language array features" do
+  include Crisp::SpecHelper
+
+  it "should raise an error on wrong number of arguments for head" do
+    lambda do
+      evaluate("(head)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'head' (0 for 1)")
+
+    lambda do
+      evaluate("(head 1 2)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'head' (2 for 1)")
+  end
+
+  it "should raise an error on invalid argument for head" do
+    lambda do
+      evaluate("(head 3)")
+    end.should raise_error(Crisp::ArgumentError, "argument is not an array")
+  end
+
+  it "should calculate the head of an array" do
+    evaluate("(head [1 2 3])").should == 1
+    evaluate("(head [2])").should == 2
+    evaluate("(head [])").should == nil
+  end
+
+  it "should raise an error on wrong number of arguments for tail" do
+    lambda do
+      evaluate("(tail)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'tail' (0 for 1)")
+
+    lambda do
+      evaluate("(tail 1 2)")
+    end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'tail' (2 for 1)")
+  end
+
+  it "should raise an error on invalid argument for tail" do
+    lambda do
+      evaluate("(tail 3)")
+    end.should raise_error(Crisp::ArgumentError, "argument is not an array")
+  end
+
+  it "should calculate the tail of an array" do
+    evaluate("(tail [1 2 3])").should == [2, 3]
+    evaluate("(tail [2])").should == []
+    evaluate("(tail [])").should == []
+  end
+end

data/spec/crisp/basic_spec.rb

@@ -3,23 +3,23 @@ require 'spec_helper'
 describe "the language" do
   include Crisp::SpecHelper
 
-  it "does not bother whitspace characters in expressions" do
+  it "should not bother whitspace 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 "raises a syntax error on invalid expressions" do
+  it "should raise a syntax error on invalid expressions" do
     lambda do
       evaluate("(()")
     end.should raise_error(Crisp::SyntaxError, "syntax error at : 0")
   end
 
-  it "binds arrays to symbols" do
+  it "should 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 foo 5)(def bla [1 2 foo])")[2].should == 5
   end
 
-  it "does not evaluate numbers" do
+  it "should not evaluate numbers" do
     lambda do
       evaluate("(3)")
     end.should raise_error(Crisp::SyntaxError, "syntax error at : 0")

data/spec/crisp/core_spec.rb

@@ -3,38 +3,38 @@ require 'spec_helper'
 describe "the core language features" do
   include Crisp::SpecHelper
 
-  it "prints results" do
+  it "should print results" do
     evaluate("(println (+ 1 1))")
   end
 
-  it "binds values to symbols" do
+  it "should bind values to symbols" do
     evaluate("(def bla 3)")
   end
 
-  it "does not allow to bind symbols twice" do
+  it "should 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
+  it "should produce 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
+  it "should use 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
+  it "should 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
+  it "should resolve primitve types" do
     evaluate("2").should == 2
     evaluate("2.1").should == 2.1
     evaluate("nil").should == nil
@@ -44,30 +44,30 @@ describe "the core language features" do
     evaluate("[1 2 3]").should == [1, 2, 3]
   end
 
-  it "can resolve bounded symbols" do
+  it "should 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
+  it "should bind symbols to value of already bound symbol" do
     evaluate("(def a 1)
               (def b a)
               b").should == 1
   end
 
-  it "has if statements" do
+  it "should evaluate 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
+  it "should evaluate 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
+  it "should 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)")
@@ -77,51 +77,51 @@ describe "the core language features" do
     end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'if' (1 for 2..3)")
   end
 
-  it "resolves symbols in if statements" do
+  it "should resolve symbols in if statements" do
     evaluate("(def foo 2)(if true foo)").should == 2
   end
 
-  it "uses local binding with let" do
+  it "should use local binding with let" do
     evaluate("(let [x 1] x)").should == 1
   end
 
-  it "uses more complex local bindings with let" do
+  it "should use more complex local bindings with let" do
     evaluate("(let [x 2 y x] (* x y))").should == 4
   end
 
-  it "evaluates several expressions within local binding" do
+  it "should evaluate several expressions within local binding" do
     evaluate("(let [x 2 y 3] (* x y) (+ x y))").should == 5
   end
 
-  it "binds symbols to global binding within local binding" do
+  it "should bind symbols to global binding within local binding" do
     evaluate("(let [x 1 y 2] (def foo (+ x y))) foo").should == 3
   end
 
-  it "overrides global binding within local binding" do
+  it "should override global binding within local binding" do
     evaluate("(def x 1)(let [x 2] x)").should == 2
   end
 
-  it "ensures that local binding is only valid within let" do
+  it "should ensure that local binding is only valid within let" do
     evaluate("(def x 1)(let [x 2] x) x").should == 1
   end
 
-  it "can handle emtpy local binding" do
+  it "should handle emtpy local binding" do
     evaluate("(let [] 2)").should == 2
   end
 
-  it "raises an error when calling let without correct argument" do
+  it "should raise an error when calling let without correct argument" do
     lambda do
       evaluate("(let 2 2)")
     end.should raise_error(Crisp::ArgumentError, "no argument list defined")
   end
 
-  it "raises an error when calling let with odd binding list" do
+  it "should raise an error when calling let with odd binding list" do
     lambda do
       evaluate("(let [x 1 y] 2)")
     end.should raise_error(Crisp::ArgumentError, "argument list has to contain even list of arguments")
   end
 
-  it "raises an error if file to be load not there" do
+  it "should raise an error if file to be load not there" do
     lambda do
       evaluate('(load "not_there")')
     end.should raise_error(Crisp::ArgumentError, /file (.*) not found/)
@@ -131,7 +131,7 @@ describe "the core language features" do
     end.should raise_error(Crisp::ArgumentError, "file /not_there.crisp not found")
   end
 
-  it "loads other crisp files" do
+  it "should load other crisp files" do
     File.open("/tmp/crisp_test_file.crisp", 'w') do |f|
       f << "(def foo 123)"
     end
@@ -139,7 +139,7 @@ describe "the core language features" do
     evaluate('(load "/tmp/crisp_test_file")(+ 1 foo)').should == 124
   end
 
-  it "uses the current environment when loading other crisp source files" do
+  it "should use the current environment when loading other crisp source files" do
     File.open("/tmp/crisp_test_file.crisp", 'w') do |f|
       f << "(def bla 123)"
     end
@@ -149,13 +149,13 @@ describe "the core language features" do
     end.should raise_error(Crisp::EnvironmentError, "bla already binded")
   end
 
-  it "raises an error if calling cond with wrong number of arguments" do
+  it "should raise an error if calling cond with wrong number of arguments" do
     lambda do
       evaluate("(cond false 1 true)")
     end.should raise_error(Crisp::ArgumentError, "argument list has to contain even list of arguments")
   end
 
-  it "has cond statement" do
+  it "should evaluate cond statement" do
     evaluate("(cond)").should == nil
     evaluate("(cond false 1 false 2)").should == nil
     evaluate("(cond true 3)").should == 3
@@ -165,41 +165,41 @@ describe "the core language features" do
     evaluate("(cond true 3 true 2 true 1)").should == 3
   end
 
-  it "does not eval expressions for unmatched condition" do
+  it "should not eval expressions for unmatched condition" do
     evaluate("(cond false (def foo 1) true 2)(def foo 2) foo").should == 2
   end
 
-  it "has a default condition in cond" do
+  it "should have a default condition in cond" do
     evaluate("(cond false 1 true 2 else 3)").should == 2
     evaluate("(cond true 1 true 2 else 3)").should == 1
     evaluate("(cond false 1 else 2 true 3)").should == 2
   end
 
-  it "raises an error when calling loop without correct argument" do
+  it "should raise an error when calling loop without correct argument" do
     lambda do
       evaluate("(loop 2 2)")
     end.should raise_error(Crisp::ArgumentError, "no argument list defined")
   end
 
-  it "raises an error when calling loop with odd binding list" do
+  it "should raise an error when calling loop with odd binding list" do
     lambda do
       evaluate("(loop [x 1 y] 2)")
     end.should raise_error(Crisp::ArgumentError, "argument list has to contain even list of arguments")
   end
 
-  it "raises an error when calling recur outside a loop" do
+  it "should raise an error when calling recur outside a loop" do
     lambda do
       evaluate("(recur 1)")
     end.should raise_error(Crisp::LoopError, "recur called outside loop")
   end
 
-  it "raises an error when calling recur with wrong number of arguments" do
+  it "should raise an error when calling recur with wrong number of arguments" do
     lambda do
       evaluate("(loop [x 1] (recur 1 2))")
     end.should raise_error(Crisp::ArgumentError, "wrong number of arguments for 'recur' (2 for 1)")
   end
 
-  it "calculates factorials using loop recur" do
+  it "should calculate factorials using loop recur" do
     evaluate("
       (def factorial
         (fn [n]
@@ -211,9 +211,17 @@ describe "the core language features" do
     ").should == 120
   end
 
-  it "raises an error when nesting loops" do
+  it "should raise an error when nesting loops" do
     lambda do
       evaluate("(loop [x 1] (loop [a 1 b 2] (+ a b)))")
     end.should raise_error(Crisp::LoopError, "nested loops are not allowed")
   end
+
+  it "should create an alias to a function symbol" do
+    evaluate("(alias fed def) (fed a 1) a").should == 1 
+  end
+
+  it "should create an alias to a value symbol" do
+    evaluate("(def foo 123) (alias bar foo) foo").should == 123
+  end
 end

data/spec/crisp/function_spec.rb

@@ -3,48 +3,48 @@ require 'spec_helper'
 describe "the languages functions" do
   include Crisp::SpecHelper
 
-  it "does not create a function when providing wrong number of arguments" do
+  it "should 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
+  it "should 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 return primitive values as result" do
+  it "should return primitive values as result" do
     evaluate("((fn [] 1))").should == 1
     evaluate('((fn [] "abc"))').should == 'abc'
     evaluate('((fn [] [1 2 3]))').should == [1, 2, 3]
     evaluate("((fn [x] x) 2)").should == 2
   end
 
-  it "creates functions" do
+  it "should create functions" do
     evaluate("(fn [arg] (+ 2 arg))")
   end
 
-  it "binds functions to symbols" do
+  it "should bind functions to symbols" do
     evaluate("(def myfn (fn [arg] (+ 1 arg)))").class.name.should == "Crisp::Function"
   end
 
-  it "calls functions" do
+  it "should call functions" do
     evaluate("(def myfn (fn [a b] (+ 1 1)))(myfn 1 2)").should == 2
   end
 
-  it "calls functions with arguments" do
+  it "should call 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
+  it "should not call 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
+  it "should instantly evaluate a function" do
     evaluate("((fn [] (+ 1 2)))").should == 3
   end
 end

data/spec/crisp/internal_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "internals" do
   include Crisp::SpecHelper
 
-  it "sets and gets values to and from the env" do
+  it "should set and get values to and from the env" do
     env = Crisp::Env.new
     env['key'] = 'value'
 
@@ -13,14 +13,14 @@ describe "internals" do
     env.has_key?(:key).should == true
   end
 
-  it "handles mismatched env reads" do
+  it "should handle 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
+  it "should not allow to set env keys twice" do
     env = Crisp::Env.new
     env['key'] = 'value'
 
@@ -29,7 +29,7 @@ describe "internals" do
     end.should raise_error(Crisp::EnvironmentError, "key already binded")
   end
 
-  it "gets values from a chained env" do
+  it "should get values from a chained env" do
     env1 = Crisp::Env.new
     env1[:key1] = 'val1'
     env1[:key2] = 'val2'
@@ -45,7 +45,7 @@ describe "internals" do
     chained[:key3].should == 'val4'
   end
 
-  it "sets values to a chained env" do
+  it "should set values to a chained env" do
     env1 = Crisp::Env.new
     env1[:key] = 'val'
 
@@ -57,4 +57,23 @@ describe "internals" do
     env2[:key].should == 'other'
     chained[:key].should == 'val'
   end
+
+  it "should set aliases" do
+    env = Crisp::Env.new
+    env[:key] = 1
+    env.alias(:alias, :key)
+    env[:alias].should == 1
+  end
+
+  it "should set aliases to a chained env" do
+    env1 = Crisp::Env.new
+    env1[:key] = 1
+    env2 = Crisp::Env.new
+
+    env = Crisp::ChainedEnv.new(env1, env2)
+
+    env[:key] = 1
+    env.alias(:alias, :key)
+    env[:alias].should == 1
+  end
 end

data/spec/crisp/native_call_invoker_spec.rb

@@ -3,25 +3,25 @@ require 'spec_helper'
 describe "NativeCallInvoker functionality" do
   include Crisp::SpecHelper
 
-  it "executes ruby native String#reverse" do
+  it "should execute ruby native String#reverse" do
     evaluate('(. reverse "foobar")').should == 'raboof'
   end
 
-  it "executes ruby native Array#first" do
+  it "should execute ruby native Array#first" do
     evaluate('(. first [1 2 3])').should == 1
   end
 
-  it "executes ruby native Array#first(n)" do
+  it "should execute ruby native Array#first(n)" do
     evaluate('(. first [1 2 3] 2)').should == [1,2]
   end
 
-  it "raises a named exception on invalid method" do
+  it "should raise a named exception on invalid method" do
     lambda do
       evaluate('(. foo "bar")')
     end.should raise_error(NoMethodError, %q{undefined method `foo' for "bar":String})
   end
 
-  it "executes calls on Ruby classes" do
+  it "should execute calls on Ruby classes" do
     evaluate("(. new String)").should == ''
     evaluate('(. new String "123")').should == '123'
     evaluate("(. new Array 5 2)").should == [2, 2, 2, 2, 2]

data/spec/crisp/string_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "string functionality" do
   include Crisp::SpecHelper
 
-  it "concats strings" do
+  it "should concat strings" do
     evaluate('(+ "foo" "bar")').should == 'foobar'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: crisp
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 8
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors: 
 - Markus Gerdes
@@ -15,41 +15,83 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-06 00:00:00 +01:00
+date: 2011-04-27 00:00:00 +02:00
 default_executable: crisp
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: treetop
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  name: crisp
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 21
+        hash: 3
         segments: 
-        - 1
-        - 4
-        - 9
-        version: 1.4.9
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
   type: :runtime
-  version_requirements: *id001
+  name: rake
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id002
 - !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :runtime
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rspec
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 27
         segments: 
         - 2
-        - 4
+        - 5
         - 0
-        version: 2.4.0
-  type: :development
-  version_requirements: *id002
+        version: 2.5.0
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  name: treetop
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 4
+        - 9
+        version: 1.4.9
+  requirement: *id005
 description: 
 email: github@mgsnova.de
 executables: 
@@ -61,12 +103,17 @@ extra_rdoc_files:
 - README.md
 files: 
 - CHANGELOG.md
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
 - autotest/discover.rb
 - bin/crisp
 - crisp.gemspec
+- examples/array.crisp
+- examples/calculation.crisp
+- examples/comparisons.crisp
 - examples/factorial.crisp
 - examples/fibonacci.crisp
 - examples/run.crisp
@@ -79,6 +126,7 @@ files:
 - lib/crisp/function_runner.rb
 - lib/crisp/functions.rb
 - lib/crisp/functions/arithmetic.rb
+- lib/crisp/functions/array.rb
 - lib/crisp/functions/core.rb
 - lib/crisp/native_call_invoker.rb
 - lib/crisp/nodes.rb
@@ -98,6 +146,7 @@ files:
 - lib/crisp/runtime.rb
 - lib/crisp/shell.rb
 - spec/crisp/arithmetics_spec.rb
+- spec/crisp/array_spec.rb
 - spec/crisp/basic_spec.rb
 - spec/crisp/core_spec.rb
 - spec/crisp/function_spec.rb
@@ -141,6 +190,7 @@ specification_version: 3
 summary: a tiny lisp-like language written in ruby using treetop.
 test_files: 
 - spec/crisp/arithmetics_spec.rb
+- spec/crisp/array_spec.rb
 - spec/crisp/basic_spec.rb
 - spec/crisp/core_spec.rb
 - spec/crisp/function_spec.rb