fancy 0.7.0 → 0.8.0

data/tests/contracts.fy

@@ -0,0 +1,51 @@
+FancySpec describe: Class Contracts with: {
+  it: "fails inclusion" when: {
+    {
+      class A {
+        include: Fancy Enumerable
+      }
+    } raises: Class Contracts InterfaceNotImplementedError
+  }
+
+  it: "doesn't fail inclusion" when: {
+    {
+      class A {
+        def each: block
+        include: Fancy Enumerable
+      }
+    } does_not raise: Class Contracts InterfaceNotImplementedError
+
+    {
+      class B {
+        provides_interface: 'each:
+        include: Fancy Enumerable
+      }
+    } does_not raise: Class Contracts InterfaceNotImplementedError
+  }
+
+  it: "returns the amount of not implemented interface methods" with: 'missing_methods_for_interface: when: {
+    class Interface {
+      expects_interface_on_inclusion: ['hello, 'world]
+    }
+    {
+      class C {
+        include: Interface
+      }
+    } raises: Class Contracts InterfaceNotImplementedError with: |e| {
+      e methods is: ['hello, 'world]
+      e interface is: Interface
+      e including_class is: C
+    }
+
+    {
+      class D {
+        def hello
+        include: Interface
+      }
+    } raises: Class Contracts InterfaceNotImplementedError with: |e| {
+      e methods is: ['world]
+      e interface is: Interface
+      e including_class is: D
+    }
+  }
+}

data/tests/distributing_proxy.fy

@@ -0,0 +1,28 @@
+FancySpec describe: Proxies DistributingProxy with: {
+  it: "forwards messages to each element in turn" when: {
+    p = Proxies DistributingProxy new: [1,2,3]
+    p is: 1
+    p is: 2
+    p is: 3
+    # and again
+    p is: 1
+    p is: 2
+    p is: 3
+    # and once more
+    p class is: Fixnum
+    p inspect is: "2"
+    p to_s is: "3"
+  }
+
+  it: "waits appropriately if all elements are currently in use" when: {
+    p = Proxies DistributingProxy new: ["foo", "bar", "baz"]
+    results = []
+    threads = (1..10) map: |i| {
+      Thread new: {
+        results << (i, p * 2)
+      }
+    }
+    threads each: @{ join }
+    results size is: 10
+  }
+}

data/tests/enumerable.fy

@@ -44,11 +44,114 @@ FancySpec describe: Fancy Enumerable with: {
     [] to_s is: ""
 
     class MyCollection {
-      include: Fancy Enumerable
       def each: block {
         (0..5) each: block
       }
+      include: Fancy Enumerable
     }
     MyCollection new to_s is: "012345"
   }
+
+  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]]
+
+    [1,2,3] in_groups_of: -1 . is: []
+    [1,2,3] in_groups_of: 0 . is: []
+    [1,2,3] in_groups_of: 1 . is: [[1],[2],[3]]
+
+    [] in_groups_of: -1 . is: []
+    [] in_groups_of: 0 . is: []
+    [] in_groups_of: 1 . is: []
+  }
+
+  it: "indicates if it's sorted" with: 'sorted? when: {
+    [] sorted? is: true
+    [1] sorted? is: true
+    [1,2] sorted? is: true
+    [2,1] sorted? is: false
+
+    (1,2,3) sorted? is: true
+    (1,3,2) sorted? is: false
+
+    "" sorted? is: true
+    "a" sorted? is: true
+    "abc" sorted? is: true
+    "fabc" sorted? is: false
+  }
+
+  it: "splits a collection at an index" with: 'split_at: when: {
+    [] split_at: 0 . is: [[],[]]
+    [1] split_at: 0 . is: [[],[1]]
+    [1] split_at: 1 . is: [[1],[]]
+
+    (1,2,3) split_at: 1 . is: [[1], [2,3]]
+    (1,2,3) split_at: 2 . is: [[1,2], [3]]
+
+    "foo" split_at: 1 . is: [["f"], ["o", "o"]]
+  }
+
+  it: "splits a collection based on a predicate block" with: 'split_with: when: {
+    [] split_with: @{ true } . is: [[],[]]
+    [] split_with: @{ false } . is: [[],[]]
+    [1] split_with: @{ true } . is: [[1], []]
+    [1] split_with: @{ false } . is: [[], [1]]
+    [1,2,3] split_with: @{ < 2 } . is: [[1], [2,3]]
+    [1,2,3] split_with: @{ <= 2 } . is: [[1,2], [3]]
+
+    "" split_with: @{ true } . is: [[], []]
+    "a" split_with: @{ true } . is: [["a"], []]
+    "a" split_with: @{ false } . is: [[], ["a"]]
+    "abcde" split_with: @{ <= "c" } . is: [["a", "b", "c"], ["d", "e"]]
+  }
+
+  it: "takes elements from itself as long a block yields true" with: 'take_while: when: {
+    (1..15) take_while: |x| { x < 10 } . is: (1 upto: 9)
+  }
+
+  it: "drops elements from itself as long a block yields true" with: 'drop_while: when: {
+    (1..15) drop_while: |x| { x < 10 } . is: (10 upto: 15)
+  }
+
+  it: "returns the first n elements" with: 'first: when: {
+    (1,2,3) first: 0 . is: []
+    (1,2,3) first: 1 . is: [1]
+    (1,2,3) first: 2 . is: [1,2]
+    (1,2,3) first: 3 . is: [1,2,3]
+    (1,2,3) first: 4 . is: [1,2,3]
+  }
+
+  it: "returns the last n elements" with: 'last: when: {
+    (1,2,3) last: 0 . is: []
+    (1,2,3) last: 1 . is: [3]
+    (1,2,3) last: 2 . is: [2,3]
+    (1,2,3) last: 3 . is: [1,2,3]
+    (1,2,3) last: 4 . is: [1,2,3]
+  }
+
+  it: "returns the elements for which a pattern matches" with: 'grep: when: {
+    "hello world" grep: /[a-h]/ . is: ["h", "e", "d"]
+    ["hello", "world", 1, 2, 3] grep: String . is: ["hello", "world"]
+    (1,2,3,4,5) grep: @{ < 2 } . is: [1] # blocks can be used as patterns, too :)
+    (1,2,3) grep: String . is: []
+    (1,2,3,4) grep: (2..3) . is: [2, 3]
+  }
+
+  it: "returns the values of calling a block for all elements for which a pattern matches" with: 'grep:taking: when: {
+    "hello world" grep: /[a-h]/ taking: 'upcase . is: ["H", "E", "D"]
+    ["hello", "world", 1, 2, 3] grep: String taking: 'upcase . is: ["HELLO", "WORLD"]
+    (1,2,3,4,5) grep: @{ < 2 } taking: 'doubled . is: [2]
+    (1,2,3) grep: String taking: 'to_s . is: []
+    (1,2,3,4) grep: (2..3) taking: 'to_s . is: ["2", "3"]
+  }
+
+  it: "joins all elements by a block" with: 'join_by: when: {
+    (1,2,3) join_by: '+ . is: $ (1,2,3) sum
+    ("foo", "bar", "baz") join_by: '+ . is: "foobarbaz"
+    [NoMethodError, IOError, ZeroDivisionError] join_by: '>< . is: (NoMethodError >< IOError >< ZeroDivisionError)
+    [NoMethodError, IOError, ZeroDivisionError] join_by: '<> . is: (NoMethodError <> IOError <> ZeroDivisionError)
+  }
 }

data/tests/exception.fy

@@ -129,4 +129,39 @@ FancySpec describe: StdError with: {
       e message is: msg
     }
   }
+
+  it: "always executes the finally block, even when raise_returning from within the try block" when: {
+    def do_something {
+      try {
+        return "Ok"
+      } finally {
+        @ran_finally? = true
+      }
+    }
+    @ran_finally? = false
+    do_something is: "Ok"
+    @ran_finally? is: true
+  }
+
+  it: "always executes the finally block, even when raising from within a catch block" when: {
+    def do_something {
+      try {
+        10 / 0
+      } catch ZeroDivisionError => e {
+        IOError new: (e message) . raise!
+      } finally {
+        @ran_finally? = true
+      }
+    }
+    @ran_finally? = false
+    { do_something } raises: IOError
+    @ran_finally? is: true
+  }
+
+  it: "raises an exception" with: 'raise: when: {
+    { StandardError raise: "error" } raises: Exception with: @{ message is: "error" }
+    { StandardError raise: "error" } raises: StandardError with: @{ message is: "error" }
+    { ArgumentError raise: "error2" } raises: ArgumentError with: @{ message is: "error2" }
+    { IOError raise: "bar" } raises: IOError with: @{ message is: "bar" }
+  }
 }

data/tests/fixnum.fy

@@ -118,7 +118,7 @@ FancySpec describe: Fixnum with: {
     sum is: ((10..19) sum)
   }
 
-  it: "tries to run a code block self amount of times or fails" with: 'try_times: when: {
+  it: "tries to run a code block self amount of times or fails" with: 'times_try: when: {
     { -2 times_try: { 2 / 0 } } does_not raise: Exception
     { -1 times_try: { 2 / 0 } } does_not raise: Exception
     { 0 times_try: { 2 / 0 } } does_not raise: Exception

data/tests/hash.fy

@@ -131,7 +131,7 @@ FancySpec describe: Hash with: {
     h includes?: nil . is: false
   }
 
-  it: "returns an object with slots based on key-value pairs in Hash" for: 'to_object when: {
+  it: "returns an object with slots based on key-value pairs in Hash" with: 'to_object when: {
     <[]> to_object slots empty? is: true
     <['name => "Chris"]> to_object tap: @{
       slots is: ['name]
@@ -151,4 +151,84 @@ FancySpec describe: Hash with: {
       b is: "hello"
     }
   }
+
+  it: "returns a hash with all entries for which a block yields true" with: 'select_keys: when: {
+    <[]> select_keys: { true } . is: <[]>
+    <[]> select_keys: { false } . is: <[]>
+    <['hello => "world"]> select_keys: { true } . is: <['hello => "world"]>
+    <['hello => "world"]> select_keys: { false } . is: <[]>
+    <['hello => "world", "world" => 'hello]> select_keys: @{ is_a?: Symbol } . is: <['hello => "world"]>
+    <[5 => 1, 4 => 2, 3 => 3, 2 => 4, 1 => 5]> select_keys: @{ <= 3 } . is: <[1 => 5, 2 => 4, 3 => 3]>
+  }
+
+  it: "returns a hash with all entries for which a block yields false" with: 'reject_keys: when: {
+    <[]> reject_keys: { true } . is: <[]>
+    <[]> reject_keys: { false } . is: <[]>
+    <['hello => "world"]> reject_keys: { true } . is: <[]>
+    <['hello => "world"]> reject_keys: { false } . is: <['hello => "world"]>
+    <['hello => "world", "world" => 'hello]> reject_keys: @{ is_a?: Symbol } . is: <["world" => 'hello]>
+    <[5 => 1, 4 => 2, 3 => 3, 2 => 4, 1 => 5]> reject_keys: @{ <= 3 } . is: <[5 => 1, 4 => 2]>
+  }
+
+  class HashCallable {
+    read_write_slots: ('foo, 'bar)
+  }
+
+  it: "is callable, like a block" with: 'call: when: {
+    hc = HashCallable new
+
+    hc foo is: nil
+    hc bar is: nil
+
+    <['foo: => "bar", 'bar: => 123]> call: [hc] . is: hc
+
+    hc foo is: "bar"
+    hc bar is: 123
+
+    <['foo => "foobar", 'bar => 456]> call: [hc]
+
+    hc foo is: "foobar"
+    hc bar is: 456
+  }
+
+  it: "returns itself as a block" with: 'to_block when: {
+    hc = HashCallable new
+
+    hc foo is: nil
+    hc bar is: nil
+
+    <['foo: => "hello", 'bar: => "world"]> tap: |hash| {
+      block = hash to_block
+      block is_a?: Block . is: true
+      block arity is: 1
+      block call: [hc] . is: hc
+    }
+
+    hc foo is: "hello"
+    hc bar is: "world"
+
+    <['foo => 123, 'bar => 'baz]> to_block call: [hc]
+
+    hc foo is: 123
+    hc bar is: 'baz
+  }
+
+  it: "returns a nested Hash" with: 'to_hash_deep when: {
+    <[]> to_hash_deep is: <[]>
+    <['foo => "bar"]> to_hash_deep is: <['foo => "bar"]>
+    <['foo => {bar: "baz"}]> to_hash_deep is: <['foo => <['bar => "baz"]>]>
+    <[
+      'foo => {
+        bar: {
+          baz: "quux"
+        }
+      }
+    ]> to_hash_deep is: <[
+      'foo => <[
+        'bar => <[
+          'baz => "quux"
+        ]>
+      ]>
+    ]>
+  }
 }

data/tests/integer.fy

@@ -0,0 +1,9 @@
+FancySpec describe: Integer with: {
+  it: "returns its decimals as an array" with: 'decimals when: {
+    (0..9) each: |i| { i decimals is: [i] }
+    10 decimals is: [1, 0]
+    100 decimals is: [1, 0, 0]
+    123 decimals is: [1, 2, 3]
+    998811 decimals is: [9, 9, 8, 8, 1, 1]
+  }
+}

data/tests/matchers.fy

@@ -0,0 +1,18 @@
+FancySpec describe: Matchers with: {
+  it: "matches with any value defined matching" when: {
+    m = Matchers MatchAny new: 1 with: 2
+    m === 0 is: false
+    m === 1 is: true
+    m === 2 is: true
+    m === 3 is_not: true
+  }
+
+  it: "matches only with all values defined matching" when: {
+    m = Matchers MatchAll new: Integer with: Fixnum
+    m === -1 is: true
+    m === 0 is: true
+    m === 1 is: true
+    m === 2.1 is_not: true
+    m === 0.0 is_not: true
+  }
+}

data/tests/method.fy

@@ -16,14 +16,10 @@ FancySpec describe: Method with: {
 
   it: "returns the amount of arguments a Method takes" with: 'arity when: {
     class Foo {
-      def no_args {
-      }
-      def one_arg: yo {
-      }
-      def two: a args: b {
-      }
-      def three: a args: b ok: c {
-      }
+      def no_args
+      def one_arg: yo
+      def two: a args: b
+      def three: a args: b ok: c
     }
 
     Foo instance_method: 'no_args . arity is: 0
@@ -86,13 +82,11 @@ FancySpec describe: Method with: {
   }
 
   class Foo {
-    def bar {
-    }
-    def private_bar {
-    }
+    def bar
+    def private_bar
     private: 'private_bar
-    def protected_bar {
-    }
+
+    def protected_bar
     protected: 'protected_bar
   }
 

data/tests/object.fy

@@ -215,6 +215,22 @@ FancySpec describe: Object with: {
     }
   }
 
+  it: "calls a given block with self if the block takes an argument" with: 'do: when: {
+    arr = []
+    arr do: @{
+      << 1
+      << 2
+      << 3
+      select!: 'even?
+    } . is: [2]
+
+    arr do: @{
+      is: [2] # same
+    }
+
+    2 do: @{ inspect } . is: 2
+  }
+
   it: "calls a given block with the receiver before returning itself" with: 'tap: when: {
     10 + 2 tap: |x| {
       x is: 12
@@ -259,7 +275,7 @@ FancySpec describe: Object with: {
     o2 get_slot: 'slot2 == (o1 slot2) is: true
   }
 
-  it: "returns itself when return is send as a message" with: 'return when: {
+  it: "returns itself when return is send as a message" when: {
     def foo: array {
       array each: @{ return }
     }
@@ -277,7 +293,7 @@ FancySpec describe: Object with: {
     v is: [1]
   }
 
-  it: "provides temporarily mutable slots" with: 'with_mutable_slots: when: {
+  it: "provides temporarily mutable slots" with: 'with_mutable_slots:do: when: {
     class Student {
       read_slots: ('name, 'age, 'city)
       def initialize: block {
@@ -304,4 +320,62 @@ FancySpec describe: Object with: {
     p age is: 24
     p city is: "Osnabrück"
   }
+
+  it: "ignores all specified exception types" with: 'ignoring:do: when: {
+    {
+      [{ 2 / 0 }, { "foo" unknown_method_on_string! }] each: |b| {
+        ignoring: (ZeroDivisionError, NoMethodError) do: b
+      }
+    } does_not raise: Exception
+  }
+
+  it: "rebinds a singleton method within a block" with: 'rebind_method:with:within: when: {
+    s = "foo"
+    s rebind_method: 'hello with: { 42 } within: {
+      s hello is: 42
+    }
+
+    s rebind_method: 'hello with: 'to_s within: {
+      s hello is: "foo"
+    }
+
+    { s hello } raises: NoMethodError
+
+    def s bar {
+      "bar!"
+    }
+
+    s bar is: "bar!"
+
+    s rebind_method: 'bar with: { "new bar!" } within: {
+      s bar is: "new bar!"
+    }
+
+    s rebind_method: 'bar with: { "another bar!" } within: |x| { x bar } . is: "another bar!"
+
+    s bar is: "bar!"
+  }
+
+  it: "binds a dynvar correctly" with: 'let:be:in:ensuring: when: {
+    *var* is: nil
+    let: '*var* be: 'hello in: {
+      *var* is: 'hello
+    } ensuring: {
+      *var* is: 'hello
+    }
+    *var* is: nil
+
+    @val = nil
+    def check {
+      *var* is: @val
+    }
+
+    check
+    @val = "test"
+    let: '*var* be: @val in: {
+      check
+    }
+    @val = nil
+    check
+  }
 }