fancy 0.3.3 → 0.4.0

data/lib/version.fy

@@ -1,6 +1,6 @@
 VERSION_MAJOR = 0
-VERSION_MINOR = 3
-VERSION_PATCH = 3
+VERSION_MINOR = 4
+VERSION_PATCH = 0
 VERSION_SUFFIX = "alpha"
 
 FANCY_VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH] join: "." ++ " " ++ VERSION_SUFFIX

data/ruby_lib/fancy

@@ -0,0 +1,43 @@
+#!/usr/bin/env rbx
+# -*- ruby -*-
+
+base = File.dirname(__FILE__)
+require File.expand_path("../boot/fancy_ext", base)
+
+# Use the bootstrapping code loader.
+require File.expand_path("../boot/load", base)
+
+do_retry = true
+begin
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/boot", base)
+
+  # Remove the bootstrapping code loader
+  bcl = Fancy.send :remove_const, :CodeLoader
+  bcl.load_compiled_file File.expand_path("../lib/rbx/code_loader", base)
+
+  # Initialize the load path
+  Fancy::CodeLoader.push_loadpath File.expand_path("../lib", base)
+
+  # Load compiler+eval support
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/eval", base)
+
+  # Run main
+  Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/main", base)
+
+rescue RuntimeError => e
+  if e.message =~ /File not found (.*)lib\/boot.fyc/
+    if do_retry
+      puts "Fancy hasn't been bootstrapped yet. Doing that now.\n\n"
+      `cd #{base} && rbx -S rake clean && rbx -S rake`
+      do_retry = false
+      retry
+    else
+      raise e
+    end
+  else
+    raise e
+  end
+rescue Interrupt => e
+  puts e
+  exit
+end

data/ruby_lib/fdoc

@@ -0,0 +1,23 @@
+#!/usr/bin/env rbx
+# -*- ruby -*-
+
+class Fancy; end
+class Fancy::Parser; end
+
+# fdoc is a documentation generator for fancy.
+# This is a ruby script because we need to setup a hook
+# BEFORE any fancy code is loaded. So we can create
+# documentation for Fancy's builtin objects as well.
+# See fdoc.
+base = File.expand_path("../boot", File.dirname(__FILE__))
+require File.expand_path("rbx-compiler/parser/fancy_parser", base)
+require File.expand_path("rbx-compiler/compiler", base)
+require File.expand_path("code_loader", base)
+require File.expand_path("fancy_ext", base)
+
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx/documentation.fyc", base)
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/fdoc_hook.fyc", base)
+
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/rbx.fyc", base)
+
+Fancy::CodeLoader.load_compiled_file File.expand_path("../lib/fdoc.fyc", base)

data/ruby_lib/fspec

@@ -0,0 +1,3 @@
+#!/usr/bin/env rbx
+base = File.expand_path("../bin", File.dirname(__FILE__))
+system("/usr/bin/env fancy #{base}/fspec #{ARGV.join(' ')}")

data/ruby_lib/fyi

@@ -0,0 +1,3 @@
+#!/usr/bin/env rbx
+base = File.expand_path("../bin", File.dirname(__FILE__))
+system("/usr/bin/env fancy #{base}/fyi #{ARGV.join(' ')}")

data/ruby_lib/ifancy

@@ -0,0 +1,3 @@
+#!/usr/bin/env rbx
+base = File.expand_path("../bin", File.dirname(__FILE__))
+system("/usr/bin/env fancy #{base}/ifancy #{ARGV.join(' ')}")

data/tests/argv.fy

@@ -1,14 +1,10 @@
 FancySpec describe: "ARGV & predefined values" with: {
-  it: "should have ARGV correctly defined" when: {
-    ARGV empty? should_not == true
+  it: "has ARGV correctly defined" when: {
+    ARGV empty? is_not: true
   }
 
-  it: "should have a __FILE__ variable defined" when: {
-    __FILE__ should_not == nil
-    __FILE__ should =~ /\/argv.fy$/
-  }
-
-  it: "should have the __FILE__ value be an element in ARGV" when: {
-    ARGV any?: |a| { File basename(a) == (File basename(__FILE__)) } . should == true
+  it: "has a __FILE__ variable defined" when: {
+    __FILE__ is_not: nil
+    __FILE__ is =~ /\/argv.fy$/
   }
 }

data/tests/array.fy

@@ -1,374 +1,501 @@
 FancySpec describe: Array with: {
-  it: "should contain three number values after adding them" for: '<< when: {
+  it: "contains three number values after adding them" with: '<< when: {
     arr = []
     arr << 1
     arr << 2
     arr << 3
-    arr should == [1,2,3]
-    arr size should == 3
+    arr is: [1,2,3]
+    arr size is: 3
   }
 
-  it: "should iterate over all elements, calling a block" for: 'each: when: {
+  it: "iterates over all elements, calling a block" with: 'each: when: {
     sum = 0
     [1,2,3,4,5] each: |x| { sum = sum + x }
-    sum should == ([1,2,3,4,5] sum)
+    sum is: $ [1,2,3,4,5] sum
   }
 
-  it: "should be empty after clearing it" for: 'clear when: {
+  it: "iterates over all elements in reverse" with: 'reverse_each: when: {
+    sum = 0
+    last = 5
+    count = 0
+    [1,2,3,4,5] reverse_each: |x| {
+      x <= last is: true
+      last = x
+      sum = sum + x
+      count = count + 1
+    }
+    sum is: $ [1,2,3,4,5] sum
+    count is: 5
+    last is: 1
+  }
+
+  it: "iterates over all elements with their index" with: 'each_with_index: when: {
+    sum = 0
+    idx_sum = 0
+    [10,20,30,40,50] each_with_index: |x i| {
+      sum = sum + x
+      idx_sum = idx_sum + i
+    }
+    sum is: 150
+    idx_sum is: 10
+  }
+
+  it: "is empty after clearing it" with: 'clear when: {
     arr = [1,2,3]
-    arr size should == 3
-    arr should == [1,2,3]
+    arr size is: 3
+    arr is: [1,2,3]
     arr clear
-    arr size should == 0
-    arr should == []
+    arr size is: 0
+    arr is: []
   }
 
-  it: "should be true for empty? when it's empty" for: 'empty? when: {
-    [] empty? should == true
-    [1] empty? should == false
-    [1,2] empty? should == false
-    [1,2,3] empty? should == false
+  it: "is true for empty? when it's empty" with: 'empty? when: {
+    [] empty? is: true
+    [1] empty? is: false
+    [1,2] empty? is: false
+    [1,2,3] empty? is: false
   }
 
-  it: "should be an empty array after initialization" for: 'new when: {
+  it: "is an empty array after initialization" with: 'new when: {
     arr = Array new
-    arr size should == 0
+    arr size is: 0
   }
 
-  it: "should return the correct value via index access" for: 'at: when: {
+  it: "returns the correct value via index access" with: 'at: when: {
     arr = ['a, 10, "hello, world"]
-    arr at: 2 . should == "hello, world"
-    arr at: 1 . should == 10
-    arr at: 0 . should == 'a
+    arr at: 2 . is: "hello, world"
+    arr at: 1 . is: 10
+    arr at: 0 . is: 'a
   }
 
-  it: "should set the value for a given index" for: 'at:put: when: {
+  it: "sets the value for a given index" with: '[]: when: {
     arr = [1,2,3]
-    arr at: 0 put: 10
-    arr should == [10, 2, 3]
-    arr at: -1 put: 30
-    arr should == [10, 2, 30]
-    arr at: 1 put: 20
-    arr should == [10,20,30]
-    arr at: 3 put: 40
-    arr should == [10,20,30,40]
+    arr[0]: 10
+    arr is: [10, 2, 3]
+    arr[-1]: 30
+    arr is: [10, 2, 30]
+    arr[1]: 20
+    arr is: [10,20,30]
+    arr[3]: 40
+    arr is: [10,20,30,40]
   }
 
-  it: "should NOT include the items" for: "includes?:" when: {
+  it: "does NOT include the items" with: 'includes?: when: {
     arr = ['a, 10, "hello, world"]
-    arr includes?: "hello" . should == false
-    arr includes?: 11 . should == false
-    arr includes?: 'b . should == false
+    arr includes?: "hello" . is: false
+    arr includes?: 11 . is: false
+    arr includes?: 'b . is: false
   }
 
-  it: "should include the items" for: 'includes?: when: {
+  it: "includes the items" with: 'includes?: when: {
     arr = ['a, 10, "hello, world"]
-    arr includes?: "hello, world" . should == true
-    arr includes?: 10 . should == true
-    arr includes?: 'a . should == true
+    arr includes?: "hello, world" . is: true
+    arr includes?: 10 . is: true
+    arr includes?: 'a . is: true
   }
 
-  it: "should return the correct index (or nil) for an element" for: 'index: when: {
+  it: "returns the correct index (or nil) for an element" with: 'index: when: {
     arr = [1, 2, 'a, 3, 4]
-    arr index: 1 . should == 0
-    arr index: 2 . should == 1
-    arr index: 'a . should == 2
-    arr index: 3 . should == 3
-    arr index: 4 . should == 4
-    arr index: 'foo . should == nil
+    arr index: 1 . is: 0
+    arr index: 2 . is: 1
+    arr index: 'a . is: 2
+    arr index: 3 . is: 3
+    arr index: 4 . is: 4
+    arr index: 'foo . is: nil
   }
 
-  it: "should return an Array of all its indices" for: 'indices when: {
-    ['foo, 'bar, 'baz] indices should == [0,1,2]
-    [] indices should == []
-    ['foo] indices should == [0]
+  it: "returns an Array of all its indices" with: 'indices when: {
+    ['foo, 'bar, 'baz] indices is: [0,1,2]
+    [] indices is: []
+    ['foo] indices is: [0]
   }
 
-  it: "should return all indices for an element as an Array" for: 'indices: when: {
+  it: "returns all indices for an element as an Array" with: 'indices_of: when: {
     arr = [1, 2, 'a, 3, 2, 'a]
-    arr indices_of: 1 . should == [0]
-    arr indices_of: 2 . should == [1, 4]
-    arr indices_of: 'a . should == [2, 5]
-    arr indices_of: 3. should == [3]
-    arr indices_of: 'foo . should == []
+    arr indices_of: 1 . is: [0]
+    arr indices_of: 2 . is: [1, 4]
+    arr indices_of: 'a . is: [2, 5]
+    arr indices_of: 3. is: [3]
+    arr indices_of: 'foo . is: []
   }
 
-  it: "should find the value" for: 'find: when: {
+  it: "finds the value" with: 'find: when: {
     arr = ['foo, "bar", 'baz, 1234]
 
-    arr find: "bar" . should == "bar"
+    arr find: "bar" . is: "bar"
 
     arr find: |x| {
       x is_a?: String . if_true: {
         x from: 0 to: 1 == "ba"
       }
-    } . should == "bar"
+    } . is: "bar"
 
-    arr find: "foo" . should == nil
+    arr find: "foo" . is: nil
   }
 
-  it: "should NOT find the value" for: 'find: when: {
+  it: "does NOT find the value" with: 'find: when: {
     arr = ['foo, "bar", 'baz, 1234]
 
-    arr find: "ba" . should == nil
+    arr find: "ba" . is: nil
 
     arr find: |x| {
       x is_a?: String . if_true: {
         x from: 0 to: 1 == "aa"
       }
-    } . should == nil
+    } . is: nil
 
-    arr find: "foobar" . should == nil
+    arr find: "foobar" . is: nil
   }
 
-  it: "should find the value via a block" for: 'find_by: when: {
+  it: "finds the value via a block" with: 'find_by: when: {
     arr = [1, 2, 'foo, "yo", nil, true]
-    arr find_by: |x| { x is_a?: String } . should == "yo"
-    arr find_by: |x| { x is_a?: Block } . should == nil
+    arr find_by: |x| { x is_a?: String } . is: "yo"
+    arr find_by: |x| { x is_a?: Block } . is: nil
   }
 
-  it: "should return the last element" for: 'last when: {
+  it: "returns the last element" with: 'last when: {
     arr = [1, 2, 3, 'foo, "bar"]
-    arr last should == "bar"
-    (arr last == 'foo) should == false
+    arr last is: "bar"
+    (arr last == 'foo) is: false
   }
 
-  it: "should return the last n element" for: 'last: when: {
+  it: "returns the last n element" with: 'last: when: {
     arr = [1, 2, 3, 'foo, "bar"]
-    arr last: 1 . should == [arr last]
-    arr last: 2 . should == ['foo, "bar"]
-    arr last: 3 . should == [3, 'foo, "bar"]
-    arr last: 4 . should == [2, 3, 'foo, "bar"]
-    arr last: 5 . should == [1, 2, 3, 'foo, "bar"]
-    arr last: (arr size) . should == arr
-    arr last: (arr size + 1) . should == arr
+    arr last: 1 . is: [arr last]
+    arr last: 2 . is: ['foo, "bar"]
+    arr last: 3 . is: [3, 'foo, "bar"]
+    arr last: 4 . is: [2, 3, 'foo, "bar"]
+    arr last: 5 . is: [1, 2, 3, 'foo, "bar"]
+    arr last: (arr size) . is: arr
+    arr last: (arr size + 1) . is: arr
   }
 
-  it: "should return an array containing the values at the given indices" for: 'values_at: when: {
+  it: "returns an array containing the values at the given indices" with: 'values_at: when: {
     arr = [1, 2, 3, 'foo, "bar"]
-    arr values_at: [1, 3, 4, 10] . should == [2, 'foo, "bar", nil]
+    arr values_at: [1, 3, 4, 10] . is: [2, 'foo, "bar", nil]
   }
 
-  it: "should return unique values only" for: 'uniq when: {
+  it: "returns unique values only" with: 'uniq when: {
     arr = ['foo, 'bar, "baz", 'foo, "baz", "hello", 1, 0, 0, 1, 'bar, 'foo, "hello"]
-    arr uniq should == ['foo, 'bar, "baz", "hello", 1, 0]
+    arr uniq is: ['foo, 'bar, "baz", "hello", 1, 0]
   }
 
-  it: "should prepend self to another array" for: '>> when: {
+  it: "prepends self to another array" with: '>> when: {
     arr1 = ['foo, 'bar, 'baz]
     arr2 = [1, 2, 3]
-    (arr1 >> arr2) should == ['foo, 'bar, 'baz, 1, 2, 3]
+    (arr1 >> arr2) is: ['foo, 'bar, 'baz, 1, 2, 3]
   }
 
-  it: "should get an element by the []-operator" for: "[]" when: {
+  it: "returns an element by the []-operator" with: '[] when: {
     arr = ['foo, 'bar, 'baz]
-    arr[0] should == 'foo
-    arr[1] should == 'bar
-    arr[2] should == 'baz
+    arr[0] is: 'foo
+    arr[1] is: 'bar
+    arr[2] is: 'baz
   }
 
-  it: "should get a sub-array by the []-operator" for: "[]" when: {
+  it: "returns a sub-array by the []-operator" with: '[] when: {
     arr = ['foo, 'bar, 'baz]
-    arr[[0,2]] should == arr
-    arr[[0,1]] should == ['foo, 'bar]
-    arr[[0,1]] should == (arr from: 0 to: 1)
-    arr[[0,0]] should == [arr[0]]
-    arr[[1,1]] should == [arr[1]]
-    arr[[2,2]] should == [arr[2]]
-    arr[[0,-1]] should == arr
-    arr[[-1,-1]] should == [arr last]
-    arr[[-2,-1]] should == ['bar, 'baz]
-    arr[[-2,-1]] should == (arr last: 2)
-  }
-
-  it: "should join all elements with a string to a new string" for: 'join: when: {
+    arr[[0,2]] is: arr
+    arr[[0,1]] is: ['foo, 'bar]
+    arr[[0,1]] is: (arr from: 0 to: 1)
+    arr[[0,0]] is: [arr[0]]
+    arr[[1,1]] is: [arr[1]]
+    arr[[2,2]] is: [arr[2]]
+    arr[[0,-1]] is: arr
+    arr[[-1,-1]] is: [arr last]
+    arr[[-2,-1]] is: ['bar, 'baz]
+    arr[[-2,-1]] is: (arr last: 2)
+  }
+
+  it: "joins all elements with a string to a new string" with: 'join: when: {
     arr = ['foo, 'bar, 'baz]
-    arr join: "," . should == "foo,bar,baz"
+    arr join: "," . is: "foo,bar,baz"
   }
 
-  it: "should join all elements with the empty string to a new string" for: 'join when: {
+  it: "joins all elements with the empty string to a new string" with: 'join when: {
     arr = ['foo, 'bar, 'baz]
-    arr join should == "foobarbaz"
+    arr join is: "foobarbaz"
   }
 
-  it: "should remove an element at a given index" for: 'remove_at: when: {
+  it: "removes an element at a given index" with: 'remove_at: when: {
     arr = [1, 'foo, 2, 'bar, 3, 'baz]
     # remove_at: returns the removed element
-    arr remove_at: 1 . should == 'foo
-    arr should == [1, 2, 'bar, 3, 'baz]
+    arr remove_at: 1 . is: 'foo
+    arr is: [1, 2, 'bar, 3, 'baz]
     arr remove_at: 3
-    arr should == [1, 2, 'bar, 'baz]
+    arr is: [1, 2, 'bar, 'baz]
     arr remove_at: [2, 3]
-    arr should == [1, 2]
+    arr is: [1, 2]
     arr = [1, 'hello, 2, 'world]
     # remove_at: returns the removed elements as an array
     # if it was passed an array of indexes
-    arr remove_at: [0, 2, 3] . should == [1, 2, 'world]
-    arr should == ['hello]
+    arr remove_at: [0, 2, 3] . is: [1, 2, 'world]
+    arr is: ['hello]
   }
 
-  it: "should remove all occurances of a given object in-place" for: 'remove: when: {
+  it: "removes all occurances of a given object in-place" with: 'remove: when: {
     arr = [1, 2, 'foo, 3, 'foo, 2, 4]
     arr remove: 2
-    arr should == [1, 'foo, 3, 'foo, 4]
+    arr is: [1, 'foo, 3, 'foo, 4]
     arr remove: 'foo
-    arr should == [1, 3, 4]
+    arr is: [1, 3, 4]
   }
 
-  it: "should remove all elements with the given Array of indices" for: 'remove_at: when: {
+  it: "removes all elements with the given Array of indices" with: 'remove_at: when: {
     arr = [1, 2, 'foo, 3, 'foo, 2, 4]
     arr remove_at: [0, 2, 4]
-    arr should == [2, 3, 2, 4]
+    arr is: [2, 3, 2, 4]
   }
 
-  it: "should remove all elements that meet a given condition block" for: 'remove_if: when: {
+  it: "removes all elements that meet a given condition block" with: 'remove_if: when: {
     arr = [1, 2, 3, 2, 5, 4]
     arr remove_if: |x| { x < 3 }
-    arr should == [3, 5, 4]
+    arr is: [3, 5, 4]
   }
 
-  it: "should remove all nil-value entries when calling compact" for: 'compact when: {
-    ['foo, nil, 'bar, nil, 'baz] compact should == ['foo, 'bar, 'baz]
-    [] compact should == []
-    [nil] compact should == []
-    ['foo] compact should == ['foo]
+  it: "removes all nil-value entries when calling compact" with: 'compact when: {
+    ['foo, nil, 'bar, nil, 'baz] compact is: ['foo, 'bar, 'baz]
+    [] compact is: []
+    [nil] compact is: []
+    ['foo] compact is: ['foo]
   }
 
-  it: "should remove all nil-value entries in place when calling compact!" for: 'compact! when: {
+  it: "removes all nil-value entries in place when calling compact!" with: 'compact! when: {
     arr = ['foo, nil, 'bar, nil, 'baz]
-    arr compact! should == ['foo, 'bar, 'baz]
-    arr should == ['foo, 'bar, 'baz]
-    [] compact! should == []
-    [nil] compact! should == []
-    ['foo] compact! should == ['foo]
+    arr compact! is: ['foo, 'bar, 'baz]
+    arr is: ['foo, 'bar, 'baz]
+    [] compact! is: []
+    [nil] compact! is: []
+    ['foo] compact! is: ['foo]
   }
 
-  it: "should remove all values that meet a condition" for: 'reject!: when: {
+  it: "removes all values that meet a condition" with: 'reject!: when: {
     arr = ['foo, 'bar, 1, 2, 'baz, "hello"]
-    arr reject!: |x| { x is_a?: String } . should == ['foo, 'bar, 1, 2, 'baz]
-    arr should == ['foo, 'bar, 1, 2, 'baz]
+    arr reject!: |x| { x is_a?: String } . is: ['foo, 'bar, 1, 2, 'baz]
+    arr is: ['foo, 'bar, 1, 2, 'baz]
     arr reject!: |x| { x is_a?: Fixnum }
-    arr should == ['foo, 'bar, 'baz]
+    arr is: ['foo, 'bar, 'baz]
   }
 
-  it: "should remove all values that don't meet a condition" for: 'select!: when: {
+  it: "removes all values that don't meet a condition" with: 'select!: when: {
     arr = ['foo, 'bar, 1, 2, 'baz, "hello"]
     arr select!: |x| { x is_a?: Fixnum }
-    arr should == [1, 2]
+    arr is: [1, 2]
   }
 
-  it: "should return a new Array with all elements that meet a given condition" for: 'select: when: {
+  it: "returns a new Array with all elements that meet a given condition" with: 'select: when: {
     arr = [1, 2, "foo", 'bar, 120]
-    arr select: |x| { x is_a?: Fixnum } . should == [1,2,120]
-    arr should == [1, 2, "foo", 'bar, 120] # select: is non-destructive
+    arr select: |x| { x is_a?: Fixnum } . is: [1,2,120]
+    arr is: [1, 2, "foo", 'bar, 120] # select: is non-destructive
   }
 
-  it: "should print the maximum value in the list" for: 'max when: {
-    [1,2,3,4] max should == 4
-    [1,5,-3,2,6,-4,-2] max should == 6
+  it: "returns the maximum value in the list" with: 'max when: {
+    [1,2,3,4] max is: 4
+    [1,5,-3,2,6,-4,-2] max is: 6
   }
 
-  it: "should print the minimum value in the list" for: 'min when: {
-    [1,2,3,4] min should == 1
-    [1,5,-3,2,6,-4,-2] min should == -4
+  it: "prints the minimum value in the list" with: 'min when: {
+    [1,2,3,4] min is: 1
+    [1,5,-3,2,6,-4,-2] min is: -4
   }
 
-  it: "should return an Array containing the elements n times." for: '* when: {
-    [1,2,3,4,5] * 2 should == [1,2,3,4,5,1,2,3,4,5]
-    [1,2,3] * 2 should == ([1,2,3] + [1,2,3])
-    ['a,'b,'c] * 4 should == ['a,'b,'c, 'a,'b,'c, 'a,'b,'c, 'a,'b,'c]
+  it: "returns an Array containing the elements n times." with: '* when: {
+    [1,2,3,4,5] * 2 is: [1,2,3,4,5,1,2,3,4,5]
+    [1,2,3] * 2 is: ([1,2,3] + [1,2,3])
+    ['a,'b,'c] * 4 is: ['a,'b,'c, 'a,'b,'c, 'a,'b,'c, 'a,'b,'c]
   }
 
-  it: "should return the concatenation of two Arrays" for: '+ when: {
-    ([1,2,3,4] + [-1,-2,-3,-4]) should == [1,2,3,4,-1,-2,-3,-4]
+  it: "returns the concatenation of two Arrays" with: '+ when: {
+    ([1,2,3,4] + [-1,-2,-3,-4]) is: [1,2,3,4,-1,-2,-3,-4]
   }
 
-  it: "should return true for all elements" for: 'all?: when: {
-    [1,2,3,4] all?: |x| { x < 5 } . should == true
-    [1,2,3,4] all?: |x| { x > 0 } . should == true
-    [1,2,3,4] all?: |x| { x > 4 } . should == false
+  it: "returns true for all elements" with: 'all?: when: {
+    [1,2,3,4] all?: |x| { x < 5 } . is: true
+    [1,2,3,4] all?: |x| { x > 0 } . is: true
+    [1,2,3,4] all?: |x| { x > 4 } . is: false
   }
 
-  it: "should return true for any elements" for: 'any?: when: {
-    [1,2,3,4] any?: |x| { x > 3 } . should == true
-    [1,2,3,4] any?: |x| { x < 4 } . should == true
-    [1,2,3,4] any?: |x| { x > 4 } . should == false
+  it: "returns true for any elements" with: 'any?: when: {
+    [1,2,3,4] any?: |x| { x > 3 } . is: true
+    [1,2,3,4] any?: |x| { x < 4 } . is: true
+    [1,2,3,4] any?: |x| { x > 4 } . is: false
   }
 
-  it: "should be selected from it with each index" for: 'select_with_index: when: {
-    ["yooo",2,3,1,'foo,"bar"] select_with_index: |x i| { x is_a?: Fixnum } . should == [[2,1], [3,2], [1,3]]
+  it: "is selected from it with each index" with: 'select_with_index: when: {
+    ["yooo",2,3,1,'foo,"bar"] select_with_index: |x i| { x is_a?: Fixnum } . is: [[2,1], [3,2], [1,3]]
   }
 
-  it: "should return its remaining (all but the first) elements as a new Array" for: 'rest when: {
-    [1,2,3,4] rest should == [2,3,4]
-    [] rest should == []
-    100 upto: 1000 . rest should == (101 upto: 1000)
+  it: "returns its remaining (all but the first) elements as a new Array" with: 'rest when: {
+    [1,2,3,4] rest is: [2,3,4]
+    [] rest is: []
+    100 upto: 1000 . rest is: (101 upto: 1000)
   }
 
-  it: "should return itself as a string" for: 'to_s when: {
-    [1,2,3] to_s should == "123"
+  it: "returns itself as a string" with: 'to_s when: {
+    [1,2,3] to_s is: "123"
   }
 
-  it: "should call a given block between calling the each block" for: 'each:in_between: when: {
+  it: "calls a given block between calling the each block" with: 'each:in_between: when: {
     arr = []
     [1,2,3] each: |x| { arr << x } in_between: { arr << "-" }
-    arr should == [1, "-", 2, "-", 3]
+    arr is: [1, "-", 2, "-", 3]
 
     str = ""
     ['foo, 'bar, 'baz] each: |x| { str = str ++ (x to_s) } in_between: { str = str ++ " " }
-    str should == "foo bar baz"
+    str is: "foo bar baz"
   }
 
-  it: "should return the reduced value for a given block and initial value" for: 'reduce:init_val: when: {
+  it: "returns the reduced value for a given block and initial value" with: 'reduce:init_val: when: {
     arr = 1 upto: 10
-    arr sum should == (arr reduce: '+ init_val: 0)
-    arr product should == (arr reduce: '* init_val: 1)
-    arr to_s should == (arr reduce: '++ init_val: "")
+    arr sum is: (arr reduce: '+ init_val: 0)
+    arr product is: (arr reduce: '* init_val: 1)
+    arr to_s is: (arr reduce: '++ init_val: "")
   }
 
-  it: "should return the reverse of itself" for: 'reverse when: {
-    [1,2,3] reverse should == [3,2,1]
-    1 upto: 10 . reverse should == (10 downto: 1)
+  it: "returns the reverse of itself" with: 'reverse when: {
+    [1,2,3] reverse is: [3,2,1]
+    1 upto: 10 . reverse is: (10 downto: 1)
   }
 
-  it: "should inverse in-place" for: 'reverse! when: {
+  it: "inverses in-place" with: 'reverse! when: {
     arr = [1,2,3]
-    arr reverse! should == [3,2,1]
-    arr should == [3,2,1]
+    arr reverse! is: [3,2,1]
+    arr is: [3,2,1]
   }
 
-  it: "should take elements from itself as long a block yields true" for: 'take_while: when: {
-    1 upto: 15 . take_while: |x| { x < 10 } . should == (1 upto: 9)
+  it: "takes elements from itself as long a block yields true" with: 'take_while: when: {
+    1 upto: 15 . take_while: |x| { x < 10 } . is: (1 upto: 9)
   }
 
 
-  it: "should drop elements from itself as long a block yields true" for: 'drop_while: when: {
-    1 upto: 15 . drop_while: |x| { x < 10 } . should == (10 upto: 15)
+  it: "drops elements from itself as long a block yields true" with: 'drop_while: when: {
+    1 upto: 15 . drop_while: |x| { x < 10 } . is: (10 upto: 15)
   }
 
-  it: "should partition an array via a given block" for: 'partition_by: when: {
+  it: "partitions an array via a given block" with: 'partition_by: when: {
     arr = [1,2,2,3,3,3,4,4,4,4,5]
-    arr partition_by: 'identity . should == [[1], [2,2], [3,3,3], [4,4,4,4], [5]]
-    arr partition_by: @{== 2} . should == [[1], [2,2], [3,3,3,4,4,4,4,5]]
+    arr partition_by: 'identity . is: [[1], [2,2], [3,3,3], [4,4,4,4], [5]]
+    arr partition_by: @{== 2} . is: [[1], [2,2], [3,3,3,4,4,4,4,5]]
   }
 
-  it: "should remove the first value" for: 'shift when: {
+  it: "removes the first value" with: 'shift when: {
     a = [1,2,3]
-    a shift should == 1
-    a should == [2,3]
+    a shift is: 1
+    a is: [2,3]
 
     a = []
-    a shift should == nil
-    a should == []
+    a shift is: nil
+    a is: []
   }
 
-  it: "should append a value at the front" for: 'unshift: when: {
+  it: "appends a value at the front" with: 'unshift: when: {
     a = []
-    a unshift: 1 . should == a # should return self
-    a should == [1]
+    a unshift: 1 . is: a # is return self
+    a is: [1]
 
     a = [1,2,3]
-    a unshift: (a shift) . should == a
-    a should == [1,2,3]
+    a unshift: (a shift) . is: a
+    a is: [1,2,3]
+  }
+
+  it: "compares 2 arrays without regard to order" with: '=? when: {
+    [1,2,3] =? [2,1,3] is: true
+    [1,2,3,4] =? [2,1,4,3] is: true
+    [1,2] =? [1,2,3] is: false
+    [1,2] =? [2] is: false
+    [2] =? [1,2] is: false
+    [] =? [] is: true
+    [1] =? [1] is: true
+  }
+
+  it: "returns the first element" with: 'first when: {
+    [1,2] first is: 1
+    [1] first is: 1
+    [] first is: nil
+  }
+
+  it: "returns the second element" with: 'second when: {
+    [1,2,3] second is: 2
+    [1,2] second is: 2
+    [1] second is: nil
+    [] second is: nil
+  }
+
+  it: "returns the third element" with: 'third when: {
+    [1,2,3,4] third is: 3
+    [1,2,3] third is: 3
+    [1,2] third is: nil
+    [1] third is: nil
+    [] third is: nil
+  }
+
+  it: "returns the fourth element" with: 'fourth when: {
+    [1,2,3,4,5] fourth is: 4
+    [1,2,3,4] fourth is: 4
+    [1,2,3] fourth is: nil
+    [1,2] fourth is: nil
+    [1] fourth is: nil
+    [] fourth is: nil
+  }
+
+  it: "returns all but the first element" with: 'rest when: {
+    [1,2,3,4] rest is: [2,3,4]
+    [2,3] rest is: [3]
+    [1] rest is: []
+    [] rest is: []
+  }
+
+  it: "returns a clone" with: 'clone when: {
+    [1,2,3] clone is: [1,2,3]
+    [1] clone is: [1]
+    [] clone is: []
+  }
+
+  it: "calculates the sum for an Array of numbers" with: 'sum when: {
+    [1,2,3] sum is: 6
+    [1] sum is: 1
+    [] sum is: 0
+  }
+
+  it: "calculates the product for an Array of numbers" with: 'product when: {
+    [1,2,3,4] product is: 24
+    [1] product is: 1
+    [] product is: 1
+  }
+
+  it: "calculates the average for an Array of numbers" with: 'average when: {
+    [] average is: 0
+    [-1] average is: -1
+    [0] average is: 0
+    [1] average is: 1
+    [1,2] average is: 1.5
+    [1,2,3] average is: 2
+    [1,2,3,4] average is: 2.5
+  }
+
+  it: "sorts the array" with: 'sort when: {
+    arr = [1,5,4,2,3]
+    arr sort is: [1,2,3,4,5]
+    arr is: [1,5,4,2,3]
+  }
+
+  it: "sorts the array with a given comparison block" with: 'sort_by: when: {
+    arr = [1,5,4,2,3]
+    sorted = [1,2,3,4,5]
+    arr sort_by: |a b| { a <=>  b } . is: sorted
+    arr is: [1,5,4,2,3]
+
+    arr = [(1,2), (0,1), (3,0)]
+    sorted = [(3,0), (0,1), (1,2)]
+    arr sort_by: |a b| { a second <=> (b second) } . is: sorted
+    arr sort_by: 'second . is: sorted
+  }
+
+  it: "returns the array in groups of 3" with: 'in_groups_of: when: {
+    ['a,'b,'c] in_groups_of: 1 . is: [['a],['b],['c]]
+    array = 1 upto: 10
+    array in_groups_of: 3 . is: [[1,2,3], [4,5,6], [7,8,9], [10]]
+
+    (20,30,40) in_groups_of: 2 . is: [[20,30], [40]]
   }
 }