fancy 0.3.2 → 0.3.3

data/tests/enumerator.fy

@@ -0,0 +1,85 @@
+FancySpec describe: FancyEnumerator with: {
+  it: "iterates with 'next" for: 'new: when: {
+    enum = FancyEnumerator new: (42..50)
+    enum next should == 42
+    enum next should == 43
+  }
+
+  it: "peeks to find next element" for: 'peek when: {
+    enum = FancyEnumerator new: (42..50)
+    enum peek should == 42
+    enum peek should == 42
+    enum next should == 42
+
+    enum peek should == 43
+    enum peek should == 43
+    enum next should == 43
+  }
+
+  it: "turns an object with 'each: into an FancyEnumerator" for: 'to_enum when: {
+    enum = (42..45) to_enum
+    enum next should == 42
+  }
+
+  it: "turns an object with given method into an FancyEnumerator" for: 'to_enum: when: {
+    o = {}
+    def o iter: block {
+      1 upto: 10 do: block
+    }
+    enum = o to_enum: 'iter:
+    enum next should == 1
+  }
+
+  it: "rewinds to the beginning of the iteration" for: 'rewind when: {
+    enum = (42..45) to_enum
+    check = {
+      enum peek should == 42
+      enum next should == 42
+      enum peek should == 43
+      enum next should == 43
+    }
+
+    check call
+    enum rewind
+    check call
+  }
+
+  it: "raises Fancy StopIteration when out of values" for: 'next when: {
+    o = Object new
+    def o each: block { block call: [1] }
+    e = o to_enum
+
+    e next should == 1
+    try {
+      e next
+      "We should not reach this line" should == true
+    } catch (Fancy StopIteration) => ex {
+      ex result should == nil
+    }
+  }
+
+  it: "sets result on Fancy StopIteration when out of values" for: 'next when: {
+    o = Object new
+    def o each: block {
+      block call: [1]
+      42
+    }
+    e = o to_enum
+
+    e next should == 1
+    try {
+      e next
+      "We should not reach this line" should == true
+    } catch (Fancy StopIteration) => ex {
+      ex result should == 42
+    }
+  }
+
+  it: "iterates with an object" for: 'with:each: when: {
+    enum = (42..45) to_enum
+    result = enum with: [] each: |val, obj| { obj << val }
+    result should == [42, 43, 44, 45]
+  }
+}
+
+# => [:each, :each_with_index, :each_with_object, :with_index, :with_object, :next_values, :peek_values, :next, :peek, :feed, :rewind, :inspect]

data/tests/exception.fy

@@ -70,20 +70,20 @@ FancySpec describe: StdError with: {
     }
   }
 
-  # it: "should raise and catch a custom exception correctly" for: 'raise! when: {
-  #   class MyError : StdError{
-  #     def initialize {
-  #       super initialize: "MyError message"
-  #     }
-  #   }
+  it: "should raise and catch a custom exception correctly" for: 'raise! when: {
+    class MyError : StdError{
+      def initialize {
+        initialize: "MyError message"
+      }
+    }
 
-  #   try {
-  #     MyError new raise!
-  #     nil should == true # will fail
-  #   } catch MyError => e {
-  #     e message should == "MyError message"
-  #   }
-  # }
+    try {
+      MyError new raise!
+      nil should == true # will fail
+    } catch MyError => e {
+      e message should == "MyError message"
+    }
+  }
 
   it: "should restart itself after being fixed in a catch clause" when: {
     y = 0

data/tests/file.fy

@@ -12,12 +12,9 @@ FancySpec describe: File with: {
     file open? should == false
   }
 
-  # it: "should be closed when not correctly opened" for: 'open? when: {
-  #   file = File new
-  #   file open? should == nil
-  #   file close
-  #   file open? should == nil
-  # }
+  it: "should be closed when not correctly opened" for: 'open? when: {
+    { file = File new } should raise: ArgumentError
+  }
 
   it: "should write and read from a file correctly" for: 'writeln: when: {
     filename = "/tmp/read_write_test.txt"
@@ -43,13 +40,7 @@ FancySpec describe: File with: {
   }
 
   it: "should raise an IOError exception when trying to open an invalid file" when: {
-    try {
-      file = File open: "/foo/bar/baz" modes: ['read]
-      nil should == true # this shouldn't execute
-    } catch IOError => e {
-      #e filename should == "/foo/bar/baz"
-      #e modes should == ['read]
-    }
+    { file = File open: "/foo/bar/baz" modes: ['read] } should raise: IOError
   }
 
   it: "should rename a File" when: {

data/tests/future.fy

@@ -0,0 +1,26 @@
+FancySpec describe: Future with: {
+  it: "should compose Futures to create execution pipelines" for: '&& 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
+  }
+}
+
+FancySpec describe: FutureCollection with: {
+  it: "should execute a block for each future in the collection when it's ready" for: 'each: when: {
+    futures = 0 upto: 10 . map: |i| {
+      i ** i @ ** i
+    }
+
+    fc = FutureCollection new: futures
+    fc each: |val| {
+      val is_a?: Integer . should == true
+    }
+
+    fc await_all
+  }
+}

data/tests/method.fy

@@ -14,57 +14,57 @@ FancySpec describe: Method with: {
   #   x give_me_the_sender! should == self
   # }
 
-  # it: "should return the amount of arguments a Method takes" for: 'argcount when: {
-  #   class Foo {
-  #     def no_args {
-  #     }
-  #     def one_arg: yo {
-  #     }
-  #     def two: a args: b {
-  #     }
-  #     def three: a args: b ok: c {
-  #     }
-  #   }
+  it: "should return the amount of arguments a Method takes" for: 'argcount when: {
+    class Foo {
+      def no_args {
+      }
+      def one_arg: yo {
+      }
+      def two: a args: b {
+      }
+      def three: a args: b ok: c {
+      }
+    }
 
-  #   Foo method: 'no_args . argcount should == 0
-  #   Foo method: "one_arg:" . argcount should == 1
-  #   Foo method: "two:args:" . argcount should == 2
-  #   Foo method: "three:args:ok:" . argcount should == 3
-  # }
+    Foo instance_method: 'no_args . arity should == 0
+    Foo instance_method: "one_arg:" . arity should == 1
+    Foo instance_method: "two:args:" . arity should == 2
+    Foo instance_method: "three:args:ok:" . arity should == 3
+  }
 
-  # it: "should return the return value" when: {
-  #   def foo: bar {
-  #     return "returning!"
-  #     bar # will never get executed
-  #   }
+  it: "should return the return value" when: {
+    def foo: bar {
+      return "returning!"
+      bar # will never get executed
+    }
 
-  #   foo: "yay" . should == "returning!"
+    foo: "yay" . should == "returning!"
 
-  #   # another example
+    # another example
 
-  #   def f: x {
-  #     x < 10 if_true: {
-  #       return 100
-  #     }
-  #     0
-  #   }
+    def f: x {
+      x < 10 if_true: {
+        return 100
+      }
+      0
+    }
 
-  #   f: 10 . should == 0
-  #   f: 9 . should == 100
+    f: 10 . should == 0
+    f: 9 . should == 100
 
-  #   # and another one
+    # and another one
 
-  #   def foo {
-  #     10 times: |i| {
-  #       i == 8 if_true: {
-  #         return i # nested return
-  #       }
-  #     }
-  #     return 0
-  #   }
+    def foo {
+      10 times: |i| {
+        i == 8 if_true: {
+          return i # nested return
+        }
+      }
+      return 0
+    }
 
-  #   self foo should == 8
-  # }
+    foo should == 8
+  }
 
   it: "should return only from block-scope not from method-scope" when: {
     def self foo {
@@ -75,42 +75,42 @@ FancySpec describe: Method with: {
       }
       0
     }
-    self foo should == 8
+    foo should == 8
   }
 
-  # it: "should return locally (from block-scope not from method-scope" when: {
-  #   def self foo {
-  #     [1,2,3] select: |x| { return_local x != 3 }
-  #   }
-  #   self foo should == [1,2]
-  # }
+  it: "should return locally (from block-scope not from method-scope" when: {
+    def self foo {
+      [1,2,3] select: |x| { return_local x != 3 }
+    }
+    foo should == [1,2]
+  }
 
-  # class Foo {
-  #   def bar {
-  #   }
-  #   def private private_bar {
-  #   }
-  #   def protected protected_bar {
-  #   }
-  # }
+  class Foo {
+    def bar {
+    }
+    def private private_bar {
+    }
+    def protected protected_bar {
+    }
+  }
 
-  # it: "should be public" for: 'public? when: {
-  #   Foo method: 'bar . public? should == true
-  #   Foo method: 'private_bar . public? should == nil
-  #   Foo method: 'protected_bar . public? should == nil
-  # }
+  it: "should be public" for: 'public? when: {
+    Foo instance_method: 'bar . public? should == true
+    Foo instance_method: 'private_bar . public? should == false
+    Foo instance_method: 'protected_bar . public? should == false
+  }
 
-  # it: "should be private" for: 'private? when: {
-  #   Foo method: 'bar . private? should == nil
-  #   Foo method: 'private_bar . private? should == true
-  #   Foo method: 'protected_bar . private? should == nil
-  # }
+  it: "should be private" for: 'private? when: {
+    Foo instance_method: 'bar . private? should == false
+    Foo instance_method: 'private_bar . private? should == true
+    Foo instance_method: 'protected_bar . private? should == false
+  }
 
-  # it: "should be protected" for: 'protected? when: {
-  #   Foo method: 'bar . protected? should == nil
-  #   Foo method: 'private_bar . protected? should == nil
-  #   Foo method: 'protected_bar . protected? should == true
-  # }
+  it: "should be protected" for: 'protected? when: {
+    Foo instance_method: 'bar . protected? should == false
+    Foo instance_method: 'private_bar . protected? should == false
+    Foo instance_method: 'protected_bar . protected? should == true
+  }
 
   it: "should set the default values for optional argument, when not passed in" when: {
     def foo: arg1 bar: arg2 ("foo") baz: arg3 (nil) {
@@ -122,6 +122,17 @@ FancySpec describe: Method with: {
     foo: "hello"  . should == "hellofoo"
   }
 
+  it: "should have default values for all arguments, if none given" when: {
+    def a: arg1 ("foo") b: arg2 ("bar") c: arg3 ("baz") {
+      [arg1, arg2, arg3]
+    }
+
+    a: "hello" b: "world" c: "!" . should == ["hello", "world", "!"]
+    a: "hello" b: "world" . should == ["hello", "world", "baz"]
+    a: "hello" . should == ["hello", "bar", "baz"]
+    a should == ["foo", "bar", "baz"]
+  }
+
   it: "should return multiple values (as a Tuple)" when: {
     def multiple_return_values: x {
       (x, x + x, x + x + x)

data/tests/nil_class.fy

@@ -1,23 +1,30 @@
 FancySpec describe: NilClass with: {
   it: "should be false for calling and: with any value" for: 'and: when: {
-    nil and: true . should == false
-    nil and: 'foo . should == false
-    nil and: nil . should == false
+    nil and: true . should == nil
+    nil and: 'foo . should == nil
+    nil and: nil . should == nil
+    false and: true . should == false
+    false and: 'foo . should == false
+    false and: nil . should == false
   }
 
-  it: "should be false for calling && with any value" for: '&& when: {
-    (nil && true) should == false
-    (nil && 'foo) should == false
-    (nil && nil) should == false
+  it: "should be nil/false for calling && with any value" for: '&& when: {
+    (nil && true) should == nil
+    (nil && 'foo) should == nil
+    (nil && nil) should == nil
+    (false && true) should == false
+    (false && 'foo) should == false
+    (false && nil) should == false
   }
 
   it: "should be true for calling or: with any non-nil value" for: 'or: when: {
     nil or: true . should == true
-    nil or: 'foo . should == true
+    nil or: 'foo . should == 'foo
   }
 
-  it: "should be nil for calling or: with a nil value" for: 'or: when: {
-    nil or: nil . should == false
+  it: "should be nil/false for calling or: with a nil/false value" for: 'or: when: {
+    nil or: nil . should == nil
+    nil or: false . should == false
   }
 
   it: "should be true for calling || with any non-nil value" for: '|| when: {
@@ -33,8 +40,8 @@ FancySpec describe: NilClass with: {
     nil if_true: { 'then } . should == nil
   }
 
-  it: "should call the block" for: 'if_false: when: {
-    nil if_false: { 'false } . should == 'false
+  it: "should not call the block" for: 'if_false: when: {
+    nil if_false: { 'false } . should == nil
   }
 
   it: "should be nil" for: 'nil? when: {
@@ -42,7 +49,7 @@ FancySpec describe: NilClass with: {
   }
 
   it: "should be false" for: 'false? when: {
-    nil false? should == true
+    nil false? should == false
   }
 
   it: "should NOT be true" for: 'true? when: {

data/tests/number.fy

@@ -24,12 +24,7 @@ FancySpec describe: Number with: {
   }
 
   it: "should raise an exception when dividing by zero" when: {
-    try {
-      10 / 0
-      "This should not happen!" should == nil
-    } catch ZeroDivisionError => err {
-      err message should == "divided by 0"
-    }
+    { 10 / 0 } should raise: ZeroDivisionError
   }
 
   it: "should calculate the correct modulo value" for: 'modulo: when: {
@@ -62,15 +57,27 @@ FancySpec describe: Number with: {
     0 upto: 10 . should == [0,1,2,3,4,5,6,7,8,9,10]
   }
 
+  it: "should iterate from 1 upto 10" for: 'upto:do: when: {
+    sum = 0
+    1 upto: 10 do: |n| { sum = sum + n }
+    sum should == 55
+  }
+
   it: "should return an array from 10 downto 0" for: 'downto: when: {
     10 downto: 0 . should == [10,9,8,7,6,5,4,3,2,1,0]
   }
 
+  it: "should iterate from 10 downto 1" for: 'downto:do: when: {
+    sum = 0
+    10 downto: 1 do: |n| { sum = sum + n }
+    sum should == 55
+  }
+
   it: "should calculate the given power of itself" for: '** when: {
     2 ** 3 should == 8
     2 ** 0 should == 1
     2 ** 1 should == 2
-    0 upto: 10 do_each: |i| {
+    0 upto: 10 do: |i| {
       i ** 0 should == 1
       i ** 1 should == i
       i ** 2 should == (i squared)
@@ -80,7 +87,7 @@ FancySpec describe: Number with: {
   it: "should be the square of self" for: 'squared when: {
     5 squared should == 25
     10 squared should == 100
-    20 upto: 50 do_each: |i| {
+    20 upto: 50 do: |i| {
       i squared should == (i * i)
     }
   }
@@ -88,7 +95,7 @@ FancySpec describe: Number with: {
   it: "should be the double value of self" for: 'doubled when: {
     5 doubled should == 10
     10 doubled should == 20
-    20 upto: 50 do_each: |i| {
+    20 upto: 50 do: |i| {
       i doubled should == (i + i)
     }
   }