fancy 0.8.0 → 0.9.0

data/tests/class.fy

@@ -355,23 +355,24 @@ FancySpec describe: Class with: {
     NameSpace Array is_not: Array
   }
 
-  # it: "returns all nested classes of a class" with: 'nested_classes when: {
-  #   class Outer {
-  #   }
-  #   Outer nested_classes is: []
-
-  #   class Outer {
-  #     class Inner1 {
-  #     }
-  #   }
-  #   Outer nested_classes is: [Outer::Inner1]
-
-  #   class Outer {
-  #     class Inner2 {
-  #     }
-  #   }
-  #   Outer nested_classes is: [Outer Inner1, Outer Inner2]
-  # }
+  it: "returns all nested classes of a class" with: 'nested_classes when: {
+    class OuterB {
+      NotAClass = 'nope
+    }
+    OuterB nested_classes is: $ Set[[]]
+
+    class OuterB {
+      class InnerB1 {
+      }
+    }
+    OuterB nested_classes is: $ Set[[OuterB::InnerB1]]
+
+    class OuterB {
+      class InnerB2 {
+      }
+    }
+    OuterB nested_classes is: $ Set[[OuterB InnerB1, OuterB InnerB2]]
+  }
 
   it: "finds other nested classes in the same parent class" when: {
     class MyOuter {
@@ -659,17 +660,21 @@ FancySpec describe: Class with: {
 
   it: "defines a lazy slot" with: 'lazy_slot:value: when: {
     class LazyClass {
-      lazy_slot: 'foo value: { Thread sleep: 0.01; 42 * @count }
-      def initialize: @count
+      read_slot: 'count
+      lazy_slot: 'foo value: { @count = @count + 1; 42 }
+      def initialize {
+        @count = 0
+      }
     }
 
-    f = LazyClass new: 2
-    start = Time now
-    f foo is: 84
-    Time now - start >= 0.01 is: true
-    start = Time now
-    f foo is: 84
-    Time now - start <= 0.01 is: true
+    f = LazyClass new
+    f count is: 0
+    f foo is: 42
+    f count is: 1
+    f foo is: 42
+    f count is: 1
+    10 times: { f foo }
+    f count is: 1
   }
 
   it: "returns a string representation of itself and its superclass, if any" with: 'inspect when: {

data/tests/control_flow.fy

@@ -1,5 +1,4 @@
 FancySpec describe: "Control Flow" with: {
-
   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

data/tests/dynamic_key_hash.fy

@@ -5,12 +5,33 @@ FancySpec describe: DynamicKeyHash with: {
       name: "Chris"
       age: 25
       country: "Germany"
+      nested: { yo: "off" }
     }
 
     hash = dkh hash
-    Set[hash keys] is: $ Set[['name, 'age, 'country]]
+    Set[hash keys] is: $ Set[['name, 'age, 'country, 'nested]]
     hash['name] is: "Chris"
     hash['age] is: 25
     hash['country] is: "Germany"
+    hash['nested] is_a?: Block . is: true
+  }
+
+  it: "returns a deeply nested hash correctly" when: {
+    dkh = DynamicKeyHash new: true
+    dkh tap: @{
+      foo: @{
+        bar: @{
+          baz: "yo"
+        }
+      }
+    }
+
+    dkh hash is: <[
+      'foo => <[
+        'bar => <[
+          'baz => "yo"
+        ]>
+      ]>
+    ]>
   }
 }

data/tests/enumerable.fy

@@ -6,6 +6,17 @@ FancySpec describe: Fancy Enumerable with: {
     [[1,2], [2,3,4], [-1]] superior_by: '< taking: 'first . is: [-1]
   }
 
+  it: "returns an Array of mapped values" with: 'map: when: {
+    [] map: 'identity . is: []
+    (1,2,3) map: 'squared . is: [1,4,9]
+    "foo" map: 'upcase . is: ["F", "O", "O"]
+  }
+
+  it: "returns an Array of mapped values by calling a block with each element and its index" with: 'map_with_index: when: {
+    [] map_with_index: 'identity . is: []
+    [1,2,3] map_with_index: |x i| { i * 2 } . is: [0,2,4]
+  }
+
   it: "chain-maps all blocks on all values" with: 'map_chained: when: {
     (1,2,3) map_chained: ('doubled, 'squared, 'to_s) . is: ["4", "16", "36"]
     (1,2,3) map_chained: (@{ + 1 }, 'to_s) . is: ["2", "3", "4"]
@@ -14,15 +25,18 @@ FancySpec describe: Fancy Enumerable with: {
   }
 
   it: "maps over its elements with their index" with: 'map_with_index: when: {
-    (1,2,3) map_with_index: |x i| {
-      x + i
-    } . is: [1,3,5]
+    (1,2,3) map_with_index: |x i| { x + i } . is: [1,3,5]
 
-    [1,2,3,4] map_with_index: |x i| {
-      i
-    } . is: [0,1,2,3]
+    [1,2,3,4] map_with_index: |_ i| { i } . is: [0,1,2,3]
 
-    [] map_with_index: |x i| { i } . is: []
+    [] map_with_index: |_ i| { i } . is: []
+  }
+
+  it: "returns a flattened Array of mapped values" with: 'flat_map: when: {
+    [] flat_map: 'identity . is: []
+    (1,2,3) flat_map: 'identity . is: [1,2,3]
+    [(1,2,3), (4,5,6)] flat_map: 'sum . is: [6, 15]
+    [[1,2,3], [4,5,6]] flat_map: 'identity . is: [1,2,3,4,5,6]
   }
 
   it: "counts the amount of elements for which a block yields true" with: 'count: when: {
@@ -83,6 +97,12 @@ FancySpec describe: Fancy Enumerable with: {
     "fabc" sorted? is: false
   }
 
+  it: "sorts by a given block" with: 'sort_by: when: {
+    [[1,2], [1,2,3], [1], []] sort_by: @{ size } . is: [[], [1], [1,2], [1,2,3]]
+    [[1,2], [1,2,3], [1], []] sort_by: 'size . is: [[], [1], [1,2], [1,2,3]]
+    ["abc", "abcd", "ab", "a", ""] sort_by: @{ size } . is: ["", "a", "ab", "abc", "abcd"]
+  }
+
   it: "splits a collection at an index" with: 'split_at: when: {
     [] split_at: 0 . is: [[],[]]
     [1] split_at: 0 . is: [[],[1]]
@@ -114,6 +134,7 @@ FancySpec describe: Fancy Enumerable with: {
 
   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)
+    "aaabcd" drop_while: /a/ . is: ["b","c","d"]
   }
 
   it: "returns the first n elements" with: 'first: when: {
@@ -154,4 +175,215 @@ FancySpec describe: Fancy Enumerable with: {
     [NoMethodError, IOError, ZeroDivisionError] join_by: '>< . is: (NoMethodError >< IOError >< ZeroDivisionError)
     [NoMethodError, IOError, ZeroDivisionError] join_by: '<> . is: (NoMethodError <> IOError <> ZeroDivisionError)
   }
+
+  it: "returns the element if found" with: 'find: when: {
+    [1,2,3] tap: @{
+      find: 0 . is: nil
+      find: 1 . is: 1
+      find: 2 . is: 2
+      find: 3 . is: 3
+      find: 4 . is: nil
+    }
+  }
+
+  it: "calls a block with the element if found" with: 'find:do: when: {
+    found = []
+    [1,2,3] tap: @{
+      insert = |x| { found << x }
+      find: 0 do: insert
+      find: 1 do: insert
+      find: 2 do: insert
+      find: 3 do: insert
+      find: 4 do: insert
+    }
+    found is: [1,2,3]
+  }
+
+  it: "calls a block with the element and its index if found" with: 'find_with_index:do: when: {
+    found = []
+    [1,2,3] tap: @{
+      insert = |x i| { found << (x,i) }
+      find_with_index: 0 do: insert
+      find_with_index: 1 do: insert
+      find_with_index: 2 do: insert
+      find_with_index: 3 do: insert
+      find_with_index: 4 do: insert
+    }
+    found is: [(1,0), (2,1), (3,2)]
+  }
+
+  it: "calls a block with an element and its indexes" with: 'for_every:with_index_do: when: {
+    found = []
+    [1,2,3,2,1] tap: @{
+      insert = |x i| { found << (x,i) }
+      for_every: 0 with_index_do: insert
+      for_every: 1 with_index_do: insert
+      for_every: 2 with_index_do: insert
+      for_every: 3 with_index_do: insert
+      for_every: 4 with_index_do: insert
+    }
+    found is: [(1,0), (1,4), (2,1), (2,3), (3,2)]
+  }
+
+  it: "calls a block with an element for every occurance" with: 'for_every:do: when: {
+    arr = [1,2,3,2,1]
+
+    c = 0
+    arr for_every: 0 do: { c = c + 1 }
+    c is: 0
+
+    arr for_every: 1 do: { c = c + 1 }
+    c is: 2
+
+    c = 0
+    arr for_every: 2 do: { c = c + 1 }
+    c is: 2
+
+    c = 0
+    arr for_every: 2 do: { c = c + 1 }
+    c is: 2
+
+    c = 0
+    arr for_every: 3 do: { c = c + 1 }
+    c is: 1
+
+    arr for_every: 1 do: @{ is: 1 }
+    arr for_every: 2 do: @{ is: 2 }
+    arr for_every: 3 do: @{ is: 3 }
+  }
+
+  it: "returns the last index of an element or nil" with: 'last_index_of: when: {
+    [] last_index_of: nil . is: nil
+    [] last_index_of: 1 . is: nil
+    [1,2,1,2] last_index_of: 1 . is: 2
+    [1,2,1,2] last_index_of: 2 . is: 3
+    [1,2,1,2] last_index_of: 3 . is: nil
+  }
+
+  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: "returns a chunked array based on a given block" with: 'chunk_by: when: {
+    [] chunk_by: @{ nil? } . is: []
+    [1] chunk_by: @{ nil? } . is: [[false, [1]]]
+    [1,2] chunk_by: @{ odd? } . is: [
+      [true, [1]],
+      [false, [2]]
+    ]
+
+    [1,3,4,5,7,2,6,8,10,9] do: @{
+      chunk_by: 'even? . is: [
+        [false, [1,3]],
+        [true, [4]],
+        [false, [5,7]],
+        [true, [2,6,8,10]],
+        [false, [9]]
+      ]
+
+      chunk_by: 'odd? . is: [
+        [true, [1,3]],
+        [false, [4]],
+        [true, [5,7]],
+        [false, [2,6,8,10]],
+        [true, [9]]
+      ]
+
+      chunk_by: 'nil? . is: [
+        [false, [1,3,4,5,7,2,6,8,10,9]]
+      ]
+    }
+  }
+
+  it: "returns a hash grouped by the value returned by a block called with the elements" with: 'group_by: when: {
+    [] group_by: 'nil? . is: <[]>
+    [1,3,5] group_by: @{ odd? } . is: <[true => [1,3,5]]>
+    (0,1,2,3) group_by: 'even? . is: <[false => [1,3], true => [0,2]]>
+    ('foo, 1, 2, 'bar) group_by: @{ class } . is: <[Symbol => ['foo, 'bar], Fixnum => [1,2]]>
+    "FooBar" group_by: @{ uppercase? } . is: <[true => ["F", "B"], false => ["o", "o", "a", "r"]]>
+  }
+
+  it: "returns its min and max value" with: 'min_max when: {
+    [] min_max is: (nil, nil)
+    [1] min_max is: (1, 1)
+    (1,2,3,4) min_max is: (1, 4)
+    (4,2,1,3) min_max is: (1, 4)
+  }
+
+  it: "returns its min and max value based on a given block" with: 'min_max_by: when: {
+    [] min_max_by: 'nil . is: (nil, nil)
+    ["foo"] min_max_by: 'size . is: ("foo", "foo")
+    ["a", "bc", "def"] min_max_by: @{ size } . is: ("a", "def")
+    ["long", "a", "bc", "def"] min_max_by: @{ size } . is: ("a", "long")
+  }
+
+  it: "returns the minimum" with: 'min when: {
+    [] min is: nil
+    [100] min is: 100
+    [0, 1] min is: 0
+    [-100, 100] min is: -100
+    [-4,-3,-2,-1,0,1,2,3,4,5] min is: -4
+  }
+
+  it: "returns the minimum based on a block" with: 'min_by: when: {
+    [] min_by: 'size . is: nil
+    [[1, 2, 3]] min_by: 'size . is: [1, 2, 3]
+    ["foo", "foobar"] min_by: @{ size } . is: "foo"
+    [[1, 2], ["foo", "bar", "baz"]] min_by: @{ size } . is: [1, 2]
+  }
+
+  it: "returns the maximum" with: 'max when: {
+    [] max is: nil
+    [100] max is: 100
+    [0, 1] max is: 1
+    [-100, 100] max is: 100
+    [-4,-3,-2,-1,0,1,2,3,4,5] max is: 5
+  }
+
+  it: "returns the maximum based on a block" with: 'max_by: when: {
+    [] max_by: 'size . is: nil
+    [[1, 2, 3]] max_by: 'size . is: [1, 2, 3]
+    ["foo", "foobar"] max_by: @{ size } . is: "foobar"
+    [[1, 2], ["foo", "bar", "baz"]] max_by: @{ size } . is: ["foo", "bar", "baz"]
+  }
+
+  it: "returns true if exactly one element yields true with a given block" with: 'one?: when: {
+    [] one?: 'nil? . is: false
+    (1,2) one?: 'odd? . is: true
+    (1,2,3) one?: 'odd? . is: false
+    "fooBar" one?: 'uppercase? . is: true
+  }
+
+  it: "returns true if a given block yields true for none of the elements" with: 'none?: when: {
+    [] none?: 'nil? . is: true
+    [1] none?: 'odd? . is: false
+    [1] none?: 'even? . is: true
+    [1,3,5] none?: 'even? . is: true
+    "foobarBaz" none?: 'uppercase? . is: false
+  }
+
+  it: "returns the sum of all the elements" with: 'sum when: {
+    [] sum is: 0
+    [1] sum is: 1
+    [-1,0,1] sum is: 0
+    (1,2,3) sum is: 6
+  }
+
+  it: "returns the product of all the elements" with: 'product when: {
+    [] product is: 1
+    [1] product is: 1
+    [1,2] product is: 2
+    [1,2,3] product is: 6
+    [-1,5,2] product is: -10
+    [1,0,1] product is: 0
+  }
+
+  it: "retuns the average value of all elements" with: 'average when: {
+    [] average is: 0
+    [1] average is: 1
+    [1,2] average is: 1.5
+    [2,4,6] average is: 4
+    [-1,0,1] average is: 0
+    [-1,1,2] average is: $ 2.0 / 3
+  }
 }

data/tests/enumerator.fy

@@ -98,6 +98,13 @@ FancySpec describe: Fancy Enumerator with: {
     10 times: { enum ended? is: false; enum next } # move forward
     enum ended? is: true
   }
+
+  it: "is an Enumerable" when: {
+    enum = (1..9) to_enum
+    enum select: 'even? . is: [2,4,6,8]
+    enum rewind
+    enum map: @{ + 1 } . is: $ (2..10) to_a
+  }
 }
 
 # => [:each, :each_with_index, :each_with_object, :with_index, :with_object, :next_values, :peek_values, :next, :peek, :feed, :rewind, :inspect]

data/tests/file.fy

@@ -17,6 +17,10 @@ FancySpec describe: File with: {
     }
   }
 
+  it: "reads all lines in a file correctly" with: 'readlines: when: {
+    File readlines: "README.md" . is: $ File read: "README.md" with: @{ readlines }
+  }
+
   it: "writes a file correctly" with: 'write:with: when: {
     dirname = "tmp"
     filename = "#{dirname}/write_test.txt"
@@ -140,4 +144,16 @@ FancySpec describe: File with: {
     ]>
     File delete: filename
   }
+
+  it: "overwrites a file correctly" with: 'overwrite:with: when: {
+    filename = "/tmp/#{Time now to_i random}_overwrite_test.fy"
+    try {
+      File write: filename with: @{ println: "foo"; println: "bar" }
+      File read: filename . is: "foo\nbar\n"
+      File overwrite: filename with: @{ println: "bar"; println: "foo" }
+      File read: filename . is: "bar\nfoo\n"
+    } finally {
+      File delete!: filename
+    }
+  }
 }

data/tests/future.fy

@@ -16,19 +16,9 @@ FancySpec describe: FutureSend with: {
     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?: FutureSend . is: true
-  #   f value is_a?: Fixnum . is: true
-  # }
-
   it: "accesses the same future from multiple threads and blocks them until the value is computed" when: {
     def another_method {
-      Thread sleep: 0.25
+      Thread sleep: 0.01
       42
     }