fancy 0.3.3 → 0.4.0

data/tests/exception.fy

@@ -9,68 +9,85 @@ class Foo {
 }
 
 FancySpec describe: StdError with: {
-  it: "should raise an exception and catch it correctly" for: 'raise! when: {
+  it: "raises an exception and catch it correctly" with: 'raise! when: {
     try {
       StdError new: "FAIL!" . raise!
-      nil should == true # this should not occur
+      nil is: true # this is not occur
     } catch StdError => ex {
-      ex message should == "FAIL!"
+      ex message is: "FAIL!"
     }
   }
 
-  it: "should raise an exception inside a method and catch it correctly" when: {
+  it: "raises an exception and have the expected error message" with: 'raise! when: {
+    {
+      StdError new: "FAIL!" . raise!
+    } raises: StdError with: |e| {
+      e message is: "FAIL!"
+    }
+
+    {
+      "FAIL, AGAIN!" raise!
+    } raises: StdError with: |e| {
+      e message is: "FAIL, AGAIN!"
+    }
+  }
+
+  it: "raises an exception inside a method and catch it correctly" when: {
     f = Foo new
-    f bar: "Don't raise here" . should == 'no_error
+    f bar: "Don't raise here" . is: 'no_error
     try {
-      f bar: 'error . should == 'no_error
+      f bar: 'error . is: 'no_error
     } catch StdError => e {
-      e message should == "Some Error"
+      e message is: "Some Error"
     }
   }
 
-  # it: "should raise a NoMethodError" when: {
+  # it: "raises a NoMethodError" when: {
   #   s = 'symbol
   #   try {
   #     s this_method_doesnt_exist!
-  #     nil should == true # should not execute
+  #     nil is: true # is not execute
   #   } catch NoMethodError => err {
-  #     err for_class should == Symbol
-  #     err method_name should == "this_method_doesnt_exist!"
+  #     err for_class is: Symbol
+  #     err method_name is: "this_method_doesnt_exist!"
   #   }
   # }
 
-  it: "should have access to variables in exception handlers defined in the surrounding scope" when: {
+  it: "has access to variables in exception handlers defined in the surrounding scope" when: {
     var = 1234
     try {
       var wont_work!
     } catch NoMethodError => err {
-      var should == 1234
+      var is: 1234
     }
   }
 
-  it: "should always evaluate the finally clause" when: {
+  it: "always evaluates the finally clause" when: {
+    set_in_finally = false
     try {
       x = 10 / 0 # ouch!
-      "This should fail!" should == true # should not get here!
+      "This is fail!" is: true # is not get here!
     } catch ZeroDivisionError => err {
-      err message should == "divided by 0"
+      err message is: "divided by 0"
     } finally {
       # this part gets always run :)
-      "It works!" should == "It works!"
+      "It works!" is: "It works!"
+      set_in_finally is: false
+      set_in_finally = true
     }
+    set_in_finally is: true
   }
 
-  it: "should raise a StdError when raising a String" for: 'raise! when: {
+  it: "raises a StdError when raising a String" with: 'raise! when: {
     msg = "A Custom Error!"
-    try {
+    {
       msg raise!
-      msg should_not == msg # this should not get executed
-    } catch StdError => e {
-      e message should == msg
+    } raises: StdError with: |e| {
+      e message is: msg
     }
   }
 
-  it: "should raise and catch a custom exception correctly" for: 'raise! when: {
+  it: "raises and catch a custom exception correctly" with: 'raise! when: {
     class MyError : StdError{
       def initialize {
         initialize: "MyError message"
@@ -79,28 +96,28 @@ FancySpec describe: StdError with: {
 
     try {
       MyError new raise!
-      nil should == true # will fail
+      nil is: true # will fail
     } catch MyError => e {
-      e message should == "MyError message"
+      e message is: "MyError message"
     }
   }
 
-  it: "should restart itself after being fixed in a catch clause" when: {
+  it: "restarts itself after being fixed in a catch clause" when: {
     y = 0
     x = 0
     try {
       x = 10 / y
     } catch ZeroDivisionError => e {
-      y should == 0
-      x should == 0
+      y is: 0
+      x is: 0
       y = 2
       retry
     }
-    y should  == 2
-    x should  == 5
+    y is  == 2
+    x is  == 5
   }
 
-  it: "should always execute the finally block when defined" when: {
+  it: "always executes the finally block when defined" when: {
     try {
       msg = "Reraise a new Exception :P"
       try {
@@ -109,7 +126,7 @@ FancySpec describe: StdError with: {
         msg raise!
       }
     } catch StdError => e {
-      e message should == msg
+      e message is: msg
     }
   }
 }

data/tests/file.fy

@@ -1,49 +1,49 @@
 FancySpec describe: File with: {
-  it: "should return an array with the openmodes symbols" for: 'open:modes: when: {
+  it: "returns an array with the openmodes symbols" with: 'open:modes: when: {
     file = File open: "README.md" modes: ['read]
-    file modes should == ['read]
+    file modes is: ['read]
     file close
   }
 
-  it: "should be open after opening it and closed after closing" for: 'close when: {
+  it: "is open after opening it and closed after closing" with: 'close when: {
     file = File open: "README.md" modes: ['read]
-    file open? should == true
+    file open? is: true
     file close
-    file open? should == false
+    file open? is: false
   }
 
-  it: "should be closed when not correctly opened" for: 'open? when: {
-    { file = File new } should raise: ArgumentError
+  it: "is closed when not correctly opened" with: 'open? when: {
+    { file = File new } raises: ArgumentError
   }
 
-  it: "should write and read from a file correctly" for: 'writeln: when: {
+  it: "writes and reads from a file correctly" with: 'writeln: when: {
     filename = "/tmp/read_write_test.txt"
     file = File open: filename modes: ['write]
     file writeln: "hello, world!"
     file writeln: "line number two"
     file close
 
-    File exists?: filename . should == true
+    File exists?: filename . is: true
 
     file = File open: filename modes: ['read]
     lines = []
     2 times: {
       lines << (file readln)
     }
-    lines[0] should == "hello, world!\n"
-    lines[1] should == "line number two\n"
-    lines should == ["hello, world!\n", "line number two\n"]
+    lines[0] is: "hello, world!\n"
+    lines[1] is: "line number two\n"
+    lines is: ["hello, world!\n", "line number two\n"]
 
     # delete file
     File delete: filename
-    File exists?: filename . should == false
+    File exists?: filename . is: false
   }
 
-  it: "should raise an IOError exception when trying to open an invalid file" when: {
-    { file = File open: "/foo/bar/baz" modes: ['read] } should raise: IOError
+  it: "raises an IOError exception when trying to open an invalid file" when: {
+    { file = File open: "/foo/bar/baz" modes: ['read] } raises: IOError
   }
 
-  it: "should rename a File" when: {
+  it: "renames a File" when: {
     dirname = "tmp/"
     filename = dirname ++ "foobar"
 
@@ -53,25 +53,25 @@ FancySpec describe: File with: {
       f writeln: "testing!"
     }
 
-    Directory exists?: dirname . should == true
-    File exists?: dirname . should == true
-    File directory?: dirname . should == true
+    Directory exists?: dirname . is: true
+    File exists?: dirname . is: true
+    File directory?: dirname . is: true
 
     File rename: filename to: (filename ++ "-new")
-    File exists?: filename . should == false
-    File exists?: (filename ++ "-new") . should == true
+    File exists?: filename . is: false
+    File exists?: (filename ++ "-new") . is: true
     File delete: (filename ++ "-new")
     Directory delete: "tmp/"
   }
 
-  it: "should be a directory" for: 'directory?: when: {
-    File directory?: "lib/" . should == true
-    File directory?: "lib/rbx" . should == true
+  it: "is a directory" with: 'directory?: when: {
+    File directory?: "lib/" . is: true
+    File directory?: "lib/rbx" . is: true
   }
 
-  it: "should NOT be a directory" for: 'directory?: when: {
-    File directory?: "src/Makefile" . should == false
-    File directory?: "README" . should == false
-    File directory?: "src/bootstrap/Makefile" . should == false
+  it: "is NOT a directory" with: 'directory?: when: {
+    File directory?: "src/Makefile" . is: false
+    File directory?: "README" . is: false
+    File directory?: "src/bootstrap/Makefile" . is: false
   }
 }

data/tests/fixnum.fy

@@ -0,0 +1,170 @@
+FancySpec describe: Fixnum with: {
+  it: "adds two numbers correctly" with: '+ when: {
+    n1 = 20
+    n2 = 22
+    n1 + n2 is: 42
+  }
+
+  it: "subtracts two numbers correctly" with: '- when: {
+    n1 = 20
+    n2 = 22
+    n1 - n2 is: -2
+  }
+
+  it: "multiplies two numbers correctly" with: '* when: {
+    n1 = 20
+    n2 = 22
+    n1 * n2 is: 440
+  }
+
+  it: "divides two numbers correctly" with: '/ when: {
+    n1 = 20
+    n2 = 10
+    n1 / n2 is: 2
+  }
+
+  it: "raises an exception when dividing by zero" when: {
+    { 10 / 0 } is raise: ZeroDivisionError
+  }
+
+  it: "calculates the correct modulo value" with: 'modulo: when: {
+    9 % 4 is: 1
+    10 modulo: 2 . is: 0
+  }
+
+  it: "does proper integer division" with: 'div: when: {
+    50 div: 10 . is: 5
+    55 div: 10 . is: 5
+    5 div: 10 . is: 0
+    ((55 div: 10) * 10) + (55 modulo: 10) is: 55
+  }
+
+  it: "is the negation" with: 'negate when: {
+    42 negate is: -42
+  }
+
+  it: "is odd" with: 'odd? when: {
+    1 odd? is: true
+    1 even? is: false
+  }
+
+  it: "is even" with: 'even? when: {
+    2 odd? is: false
+    2 even? is: true
+  }
+
+  it: "returns an array from 0 upto 10" with: 'upto: when: {
+    0 upto: 10 . is: [0,1,2,3,4,5,6,7,8,9,10]
+  }
+
+  it: "iterates from 1 upto 10" with: 'upto:do: when: {
+    sum = 0
+    1 upto: 10 do: |n| { sum = sum + n }
+    sum is: 55
+  }
+
+  it: "returns an array from 10 downto 0" with: 'downto: when: {
+    10 downto: 0 . is: [10,9,8,7,6,5,4,3,2,1,0]
+  }
+
+  it: "iterates from 10 downto 1" with: 'downto:do: when: {
+    sum = 0
+    10 downto: 1 do: |n| { sum = sum + n }
+    sum is: 55
+  }
+
+  it: "calculates the given power of itself" with: '** when: {
+    2 ** 3 is: 8
+    2 ** 0 is: 1
+    2 ** 1 is: 2
+    0 upto: 10 do: |i| {
+      i ** 0 is: 1
+      i ** 1 is: i
+      i ** 2 is: (i squared)
+    }
+  }
+
+  it: "is the square of self" with: 'squared when: {
+    5 squared is: 25
+    10 squared is: 100
+    20 upto: 50 do: |i| {
+      i squared is: (i * i)
+    }
+  }
+
+  it: "is the double value of self" with: 'doubled when: {
+    5 doubled is: 10
+    10 doubled is: 20
+    20 upto: 50 do: |i| {
+      i doubled is: (i + i)
+    }
+  }
+
+  it: "is the same when using underscores within the literal" when: {
+    50000 is: 50_000
+    100_000 is: 100000
+    100_000 is: 100_000
+    100_000 is: 100000.0
+    100_000.0 is: 100000
+    100_999.999 is: 100999.999
+  }
+
+  it: "evaluates octal literals correctly" when: {
+    0o00 is: 0
+    0o01 is: 1
+    0o07 is: 7
+    0o10 is: 8
+    0o70 is: 56
+  }
+
+  it: "evaluates binary literals correctly" when: {
+    0b00 is: 0
+    0b01 is: 1
+    0b10 is: 2
+    0b11 is: 3
+    0b100 is: 4
+  }
+
+  it: "evaluates hexadecimal literals correctly" when: {
+    0x00 is: 0
+    0x01 is: 1
+    0x0A is: 10
+    0xA0 is: 160
+    0xFF is: 255
+  }
+
+  it: "calls a block a given amount of times" with: 'times: when: {
+    times_called = 0
+    10 times: { times_called = times_called + 1 }
+    times_called is: 10
+
+    sum = 0
+    10 times: |i| { sum = sum + i }
+    sum is: ((0..9) sum)
+  }
+
+  it: "calls a block a given amount of times with an offset" with: 'times:offset: when: {
+    times_called = 0
+    sum = 0
+    10 times: |i| {
+      times_called = times_called + 1
+      sum = sum + i
+    } offset: 10
+    times_called is: 10
+    sum is: ((10..19) sum)
+  }
+
+  it: "returns the maximum" with: 'max: when: {
+    0 max: 0 . is: 0
+    1 max: 2 . is: 2
+    2 max: 1 . is: 2
+    -2 max: -3 . is: -2
+  }
+
+  it: "returns the minimum" with: 'min: when: {
+    0 min: 0 . is: 0
+    -1 min: 0 . is: -1
+    -2 min: -3 . is: -3
+    2 min: 1 . is: 1
+  }
+}

data/tests/future.fy

@@ -1,24 +1,41 @@
-FancySpec describe: Future with: {
-  it: "should compose Futures to create execution pipelines" for: '&& when: {
+FancySpec describe: FutureSend with: {
+  it: "returns a FutureSend" when: {
+    def future_send_method {
+      "hello, future world!"
+    }
+    f = self @ future_send_method
+    f is_a?: FutureSend . is: true
+    f value is: future_send_method
+  }
+
+  it: "returns nil for async sends" when: {
+    def async_send_method {
+      "hello, async world!"
+    }
+    a = self @@ async_send_method
+    a is: nil
+  }
+
+  it: "composes Futures to create execution pipelines" with: '&& when: {
     def some_computation: num {
       num upto: (num ** num ** num)
     }
 
-    f = self @ some_computation: 2 && @{select: 'even?} && 'size
-    f is_a?: Future . should == true
-    f value is_a?: Fixnum . should == true
+    f = self @ some_computation: 2 && @{select: 'even?} && @{size}
+    f is_a?: FutureSend . is: true
+    f value is_a?: Fixnum . is: true
   }
 }
 
 FancySpec describe: FutureCollection with: {
-  it: "should execute a block for each future in the collection when it's ready" for: 'each: when: {
+  it: "executes a block for each future in the collection when it's ready" with: 'each: when: {
     futures = 0 upto: 10 . map: |i| {
       i ** i @ ** i
     }
 
     fc = FutureCollection new: futures
     fc each: |val| {
-      val is_a?: Integer . should == true
+      val is_a?: Integer . is: true
     }
 
     fc await_all