fancy 0.3.3 → 0.4.0

data/tests/control_flow.fy

@@ -1,202 +1,234 @@
 FancySpec describe: "Control Flow" with: {
 
-  it: "should NOT call the block if not nil" for: 'if_nil: when: {
-    'foo if_nil: { 'is_nil } . should == nil
-    "hello, world" if_nil: { 'is_nil } . should == nil
+  it: "does NOT call the block if not nil" with: 'if_nil: when: {
+    'foo if_nil: { 'is_nil } . is: nil
+    "hello, world" if_nil: { 'is_nil } . is: nil
   }
 
-  it: "should work like if_true:" for: 'if:then: when: {
+  it: "works like if_true:" with: 'if:then: when: {
     if: (4 < 5) then: {
-      4 < 5 should == true
+      4 < 5 is: true
     }
   }
 
-  it: "should work like if_true:else: " for: 'if:then:else: when: {
+  it: "works like if_true:else: " with: 'if:then:else: when: {
     if: (4 < 5) then: {
-      4 < 5 should == true
+      4 < 5 is: true
     } else: {
-      4 < 5 should == nil
+      4 < 5 is: nil
     }
   }
 
-  it: "should work like while_true:" for: 'while:do: when: {
+  it: "works like while_true:" with: 'while:do: when: {
     x = 0
     while: { x < 10 } do: {
-      x < 10 should == true
+      x < 10 is: true
       x = x + 1
     }
-    x == 10 should == true
+    x == 10 is: true
   }
 
-  it: "should work like while_false: " for: 'until:do: when: {
+  it: "works like while_false: " with: 'until:do: when: {
     x = 0
     until: { x == 10 } do: {
-      x < 10 should == true
+      x < 10 is: true
       x = x + 1
     }
-    x == 10 should == true
+    x == 10 is: true
   }
 
-  it: "should work like if_false:: " for: 'unless:do: when: {
+  it: "calls a block while another one is true, but call it at least once" with: 'do:while: when: {
+    x = 0
+    arr = []
+    do: {
+      x < 10 is: true
+      arr << x
+      x = x + 1
+    } while: { x < 10 }
+    arr is: [0,1,2,3,4,5,6,7,8,9]
+
+    times_called = 0
+    do: {
+      times_called = times_called + 1
+    } while: { false }
+    times_called is: 1
+  }
+
+  it: "calls a block until another one is true, but call it at least once" with: 'do:until: when: {
+    x = 0
+    do: {
+      x < 10 is: true
+      x = x + 1
+    } until: { x == 10 }
+    x is: 10
+
+    times_called = 0
+    do: {
+      times_called = times_called + 1
+    } until: { true }
+    times_called is: 1
+  }
+
+  it: "works like if_false:: " with: 'unless:do: when: {
     unless: (4 > 5) do: {
-      5 > 4 should == true
+      5 > 4 is: true
     }
   }
 
-  it: "should only call the block if it's a true-ish value" for: 'if_true: when: {
+  it: "only calls the block if it's a true-ish value" with: 'if_true: when: {
     1 if_true: |num| {
       num * 10
-    } . should == 10
+    } . is: 10
 
     nil if_true: {
       "nope"
-    } . should == nil
+    } . is: nil
 
     false if_true: {
       "nope again"
-    } . should == nil
+    } . is: nil
   }
 
-  it: "should call the then_block if it's a true-ish value and call the else_block otherwise" for: 'if_true:else: when: {
+  it: "calls the then_block if it's a true-ish value and call the else_block otherwise" with: 'if_true:else: when: {
     1 if_true: |num| {
       num * 10
     } else: {
       nil
-    } . should == 10
+    } . is: 10
 
     nil if_true: {
       "nope"
     } else: {
       "yup"
-    } . should == "yup"
+    } . is: "yup"
 
     false if_true: {
       "nope again"
     } else: {
       "yup again"
-    } . should == "yup again"
+    } . is: "yup again"
   }
 
-  it: "should be possible to override the if_true:else: method and work accordingly in conditionals" when: {
-    class AClasThatIsLikeFalse {
+  it: "is possible to override the if_true:else: method and work accordingly in conditionals" when: {
+    class AClassThatIsLikeFalse {
       def if_true: block else: another_block {
         another_block call
       }
     }
 
-    obj = AClasThatIsLikeFalse new
+    obj = AClassThatIsLikeFalse new
     if: obj then: {
       'fail
     } else: {
       'success
-    } . should == 'success
+    } . is: 'success
 
     # let's get rid of this custom if_true:else: method
-    AClasThatIsLikeFalse undefine_method: 'if_true:else:
+    AClassThatIsLikeFalse undefine_method: 'if_true:else:
 
     if: obj then: {
       'now_this_is_success
     } else: {
       'fail
-    } . should == 'now_this_is_success
+    } . is: 'now_this_is_success
   }
 
-  it: "should break from an iteration" for: 'break when: {
+  it: "breaks from an iteration" with: 'break when: {
     x = 0
     until: { x == 10 } do: {
       x = x + 1
       { break } if: (x == 5)
     }
-    x == 5 should == true
+    x == 5 is: true
   }
 
-  it: "should break from an iteration with return value" for: 'break: when: {
+  it: "breaks from an iteration with return value" with: 'break: when: {
     x = 0
     y = until: { x == 10 } do: {
       x = x + 1
       { break: 42 } if: (x == 5)
     }
 
-    x should == 5
-    y should == 42
+    x is: 5
+    y is: 42
   }
 
-  it: "should skip an iteration over a Range" for: 'next when: {
+  it: "skips an iteration over a Range" with: 'next when: {
     total = 0
     (1..10) each: |i| {
       { next } if: (i == 5)
       total = total + i
     }
-    total should == 50
+    total is: 50
   }
 
-  it: "should skip an iteration over an Array" for: 'next when: {
+  it: "skips an iteration over an Array" with: 'next when: {
     total = 0
     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] each: |i| {
       { next } if: (i == 5)
       total = total + i
     }
-    total should == 50
+    total is: 50
   }
 
-  it: "should skip an iteration over an Hash" for: 'next when: {
+  it: "skips an iteration over an Hash" with: 'next when: {
     total = 0
     <['a => 1, 'b => 2, 'c => 3, 'd => 4, 'e => 5, 'f => 6]> each: |k v| {
       { next } if: (k == 'd)
       total = total + v
     }
-    total should == 17
+    total is: 17
   }
 
-  it: "stops any loop type at the correct spot" for: 'break when: {
+  it: "stops any loop type at the correct spot" with: 'break when: {
     i = 0
     loop: {
       { break } if: (i == 3)
       i = i + 1
     }
-    i should == 3
+    i is: 3
 
     i = 0
     while: { i < 5 } do: {
       { break } if: (i == 3)
       i = i + 1
     }
-    i should == 3
+    i is: 3
 
     i = 0
     0 upto: 5 do: |n| {
       i = n
       { break } if: (n == 3)
     }
-    i should == 3
+    i is: 3
   }
 
-  it: "stops any loop type at the correct spot" for: 'break: when: {
+  it: "stops any loop type at the correct spot" with: 'break: when: {
     i = 0
     loop: {
       { break: i } if: (i == 2)
       i = i + 1
-    } . should == 2
+    } . is: 2
 
     i = 0
     while: { i < 5 } do: {
       { break: i } if: (i == 2)
       i = i + 1
-    } . should == 2
+    } . is: 2
 
     i = 0
     0 upto: 5 do: |n| {
       i = n
       { break: n } if: (n == 2)
     }
-    i should == 2
+    i is: 2
   }
 
-  it: "should allow empty try blocks" when: {
+  it: "allows empty try blocks" when: {
     x = "foo"
     try {
     } finally {
-      x should == "foo"
+      x is: "foo"
     }
   }
 }

data/tests/documentation.fy

@@ -1,11 +1,11 @@
 FancySpec describe: "Documentations" with: {
-  it: "should display the documentation for a method" when: {
+  it: "displays the documentation for a method" when: {
     documentation = "Array#each: iterates over its elements, calling a given block with each element."
     Array new method: "each:" . documentation: documentation
-    Array new method: "each:" . documentation . docs first should == documentation
+    Array new method: "each:" . documentation . docs first is: documentation
   }
 
-  it: "should define a documenation string for a class and method" when: {
+  it: "defines a documenation string for a class and method" when: {
     class ClassWithDoc {
       "This class has a documentation! Yay!"
       def foo {
@@ -13,12 +13,12 @@ FancySpec describe: "Documentations" with: {
         nil
       }
     }
-    ClassWithDoc documentation should_not == ""
-    ClassWithDoc documentation should == "This class has a documentation! Yay!"
-    ClassWithDoc new method: 'foo . documentation docs should == ["bar!"]
+    ClassWithDoc documentation to_s is_not: ""
+    ClassWithDoc documentation to_s is: "This class has a documentation! Yay!"
+    ClassWithDoc new method: 'foo . documentation docs is: ["bar!"]
   }
 
-  it: "should have a documentation string for a method" when: {
-    Array new method: "first" . documentation should_not be: 'nil?
+  it: "has a documentation string for a method" when: {
+    Array new method: "first" . documentation is_not be: 'nil?
   }
 }

data/tests/enumerable.fy

@@ -0,0 +1,8 @@
+FancySpec describe: FancyEnumerable with: {
+  it: "selects the right element based on a comparison Block and an optional selection Block" with: 'superior_by:taking: when: {
+    [1,2,3,4,5] superior_by: '> . is: 5
+    [1,2,3,4,5] superior_by: '< . is: 1
+    [[1,2], [2,3,4], [], [1]] superior_by: '> taking: 'size . is: [2,3,4]
+    [[1,2], [2,3,4], [-1]] superior_by: '< taking: 'first . is: [-1]
+  }
+}

data/tests/enumerator.fy

@@ -1,42 +1,42 @@
 FancySpec describe: FancyEnumerator with: {
-  it: "iterates with 'next" for: 'new: when: {
+  it: "iterates with 'next" with: 'new: when: {
     enum = FancyEnumerator new: (42..50)
-    enum next should == 42
-    enum next should == 43
+    enum next is: 42
+    enum next is: 43
   }
 
-  it: "peeks to find next element" for: 'peek when: {
+  it: "peeks to find next element" with: 'peek when: {
     enum = FancyEnumerator new: (42..50)
-    enum peek should == 42
-    enum peek should == 42
-    enum next should == 42
+    enum peek is: 42
+    enum peek is: 42
+    enum next is: 42
 
-    enum peek should == 43
-    enum peek should == 43
-    enum next should == 43
+    enum peek is: 43
+    enum peek is: 43
+    enum next is: 43
   }
 
-  it: "turns an object with 'each: into an FancyEnumerator" for: 'to_enum when: {
+  it: "turns an object with 'each: into an FancyEnumerator" with: 'to_enum when: {
     enum = (42..45) to_enum
-    enum next should == 42
+    enum next is: 42
   }
 
-  it: "turns an object with given method into an FancyEnumerator" for: 'to_enum: when: {
+  it: "turns an object with given method into an FancyEnumerator" with: 'to_enum: when: {
     o = {}
     def o iter: block {
       1 upto: 10 do: block
     }
     enum = o to_enum: 'iter:
-    enum next should == 1
+    enum next is: 1
   }
 
-  it: "rewinds to the beginning of the iteration" for: 'rewind when: {
+  it: "rewinds to the beginning of the iteration" with: 'rewind when: {
     enum = (42..45) to_enum
     check = {
-      enum peek should == 42
-      enum next should == 42
-      enum peek should == 43
-      enum next should == 43
+      enum peek is: 42
+      enum next is: 42
+      enum peek is: 43
+      enum next is: 43
     }
 
     check call
@@ -44,21 +44,21 @@ FancySpec describe: FancyEnumerator with: {
     check call
   }
 
-  it: "raises Fancy StopIteration when out of values" for: 'next when: {
+  it: "raises Fancy StopIteration when out of values" with: 'next when: {
     o = Object new
     def o each: block { block call: [1] }
     e = o to_enum
 
-    e next should == 1
+    e next is: 1
     try {
       e next
-      "We should not reach this line" should == true
+      "We is not reach this line" is: true
     } catch (Fancy StopIteration) => ex {
-      ex result should == nil
+      ex result is: nil
     }
   }
 
-  it: "sets result on Fancy StopIteration when out of values" for: 'next when: {
+  it: "sets result on Fancy StopIteration when out of values" with: 'next when: {
     o = Object new
     def o each: block {
       block call: [1]
@@ -66,19 +66,37 @@ FancySpec describe: FancyEnumerator with: {
     }
     e = o to_enum
 
-    e next should == 1
+    e next is: 1
     try {
       e next
-      "We should not reach this line" should == true
+      "We is not reach this line" is: true
     } catch (Fancy StopIteration) => ex {
-      ex result should == 42
+      ex result is: 42
     }
   }
 
-  it: "iterates with an object" for: 'with:each: when: {
+  it: "iterates with an object" with: 'with:each: when: {
     enum = (42..45) to_enum
     result = enum with: [] each: |val, obj| { obj << val }
-    result should == [42, 43, 44, 45]
+    result is: [42, 43, 44, 45]
+  }
+
+  it: "chunks up into enums" with: 'chunk: when: {
+    enum = (1..42) to_enum
+    chunked = enum chunk: |n| { n % 3 == 0 }
+    chunked next is: [false, [1,2]]
+    chunked next is: [true, [3]]
+  }
+
+  it: "converts to an Array" with: 'to_a when: {
+    enum = (1..10) to_enum
+    enum to_a is: [1,2,3,4,5,6,7,8,9,10]
+  }
+
+  it: "has ended (no more values left)" with: 'ended? when: {
+    enum = (1..9) to_enum
+    10 times: { enum ended? is: false; enum next } # move forward
+    enum ended? is: true
   }
 }