fancy 0.3.3 → 0.4.0

data/tests/pattern_matching.fy

@@ -1,5 +1,5 @@
 FancySpec describe: "Pattern Matching" with: {
-  it: "should match a value correctly by its class" when: {
+  it: "matches a value correctly by its class" when: {
     def do_match: obj {
       match obj {
         case String -> 'string
@@ -8,50 +8,50 @@ FancySpec describe: "Pattern Matching" with: {
       }
     }
 
-    do_match: "foo" . should == 'string
-    do_match: 42 . should == 'fixnum
-    do_match: 'symbol . should == 'anything
-    do_match: Object . should == 'anything
-    do_match: 32.32 . should == 'anything
+    do_match: "foo" . is: 'string
+    do_match: 42 . is: 'fixnum
+    do_match: 'symbol . is: 'anything
+    do_match: Object . is: 'anything
+    do_match: 32.32 . is: 'anything
   }
 
-  it: "should bind a given match arg, if present, to the result of the match operation" when: {
+  it: "binds a given match arg, if present, to the result of the match operation" when: {
     match "foobarbaz" {
       case /foo([a-z]+)baz/ -> |matcher|
         local1, local2, local3 = 'ignore, 'this_too, 'this_also
-        matcher[1] should == "bar"
+        matcher[1] is: "bar"
     }
   }
 
-  it: "should only bind given match arg to the scope of the match case" when: {
+  it: "only binds a given match arg to the scope of the match case" when: {
     match "foobarbaz" {
       case /foo([a-z]+)baz/ -> |local_of_case|
-        local_of_case == nil . should == false
+        local_of_case == nil . is: false
     }
 
-    local_of_case should == nil
+    local_of_case is: nil
   }
 
-  it: "should only bind locals of the match clause to the scope of the match case" when: {
+  it: "only binds locals of the match clause to the scope of the match case" when: {
     match "foobarbaz" {
       case /foo([a-z]+)baz/ -> |local_of_case|
-        local1 = "Hi, I am some local, that should be gone after this block."
+        local1 = "Hi, I am some local, that is be gone after this block."
     }
 
-    local1 should == nil
+    local1 is: nil
   }
 
-  it: "should bind any additional match args to the matched values" when: {
+  it: "binds any additional match args to the matched values" when: {
     str = "foo bar baz"
     match str {
       case /^foo (.*) (.*)$/ -> |all, match1, match2|
-      all class should == MatchData
-      match1 should == "bar"
-      match2 should == "baz"
+      all class is: MatchData
+      match1 is: "bar"
+      match2 is: "baz"
     }
   }
 
-  it: "should return an instance of the apropriate MatchData class" when: {
+  it: "returns an instance of the apropriate MatchData class" when: {
     def create_tuple: num {
       (num, num * num) # create a Tuple
     }
@@ -59,35 +59,71 @@ FancySpec describe: "Pattern Matching" with: {
     match create_tuple: 10 {
       case Tuple -> |md, x, y, z|
         # convention: md[0] always holds the entire object that was matched.
-        md[0] should == (create_tuple: 10)
-        x should == 10
-        y should == 100
-        z should == nil # tuple only has 2 entries
+        md[0] is: (create_tuple: 10)
+        x is: 10
+        y is: 100
+        z is: nil # tuple only has 2 entries
     }
   }
 
-  it: "should match an array correctly" when: {
+  it: "matches an array correctly" when: {
     def create_array: num {
       [num, num ** 2, num ** 3, num ** 4]
     }
 
     match create_array: 2 {
       case Array -> |_, a,b,c,d|
-        a should == 2
-        b should == (2 ** 2)
-        c should == (2 ** 3)
-        d should == (2 ** 4)
+        a is: 2
+        b is: (2 ** 2)
+        c is: (2 ** 3)
+        d is: (2 ** 4)
     }
   }
 
-  it: "should not try to bind the match args if the match failed" when: {
+  it: "does not try to bind the match args if the match failed" when: {
     ["hello world!", "hello you!", "no hello here!"] each: |str| {
       match str {
         case /^hello (.*)$/ -> |_, name|
-          name should_not == nil
+          name is_not: nil
 
-        case _ -> name should == nil
+        case _ -> name is: nil
       }
     }
   }
+
+  it: "matches a Block as a pattern correctly" when: {
+    def match_it: x {
+      match x {
+        case @{is_a?: String} -> 'string
+        case @{is_a?: Symbol} -> 'symbol
+        case @{responds_to?: 'each:} ->
+          match x {
+            case @{empty?} -> 'empty
+            case _ -> 'not_empty
+          }
+        case Fixnum ->
+          match x {
+            case @{<= 3} -> '<=
+            case _ -> x * 2
+          }
+        case _ -> x to_s * 2
+      }
+    }
+
+    match_it: "hello, world!" . is: 'string
+    match_it: [] . is: 'empty
+    match_it: <[]> . is: 'empty
+    match_it: (Set new) . is: 'empty
+    match_it: (Stack new) . is: 'empty
+    match_it: [1,2,3] . is: 'not_empty
+    match_it: (1,"foo") . is: 'not_empty
+    match_it: <['foo => 'bar]> . is: 'not_empty
+    match_it: 'yo . is: 'symbol
+    match_it: 32 . is: 64
+    match_it: 4 . is: 8
+    match_it: 3 . is: '<=
+    match_it: 2 . is: '<=
+    match_it: 0 . is: '<=
+    match_it: -1 . is: '<=
+  }
 }

data/tests/range.fy

@@ -1,11 +1,11 @@
 FancySpec describe: Range with: {
-  it: "have the correct amount of elements" for: 'size when: {
-    Range new: 1 to: 10 . to_a size should == 10
-    (1..10) to_a size should == 10
-    ("a".."z") to_a size should == 26
+  it: "has the correct amount of elements" with: 'size when: {
+    Range new: 1 to: 10 . to_a size is: 10
+    (1..10) to_a size is: 10
+    ("a".."z") to_a size is: 26
   }
 
-  it: "should have a working literal syntax" when: {
-    (1..10) should == (Range new: 1 to: 10)
+  it: "has a working literal syntax" when: {
+    (1..10) is: (Range new: 1 to: 10)
   }
 }

data/tests/set.fy

@@ -1,10 +1,107 @@
 FancySpec describe: Set with: {
-  it: "should only keep unique values" for: "[]" when: {
+  it: "only keeps unique values" with: '[] when: {
     s = Set new
     s << 'foo
     s << 'foo
-    s size should == 1
-    s should == (Set[['foo]])
-    s should_not == ['foo] # Sets and Arrays differ
+    s size is: 1
+    s is: (Set[['foo]])
+    s is_not: ['foo] # Sets and Arrays differ
+  }
+
+  it: "is empty" with: 'empty? when: {
+    s = Set new
+    s empty? is: true
+    s = Set[[]]
+    s empty? is: true
+  }
+
+  it: "is not empty" with: 'empty? when: {
+    s = Set new
+    s << 1
+    s empty? is: false
+    s = Set[[1,2,3]]
+    s empty? is: false
+  }
+
+  it: "has the correct size" with: 'size when: {
+    s = Set new
+    s size is: 0
+    s << 'foo
+    s size is: 1
+    10 times: {
+      s << 'bar # only inserted once
+    }
+    s size is: 2
+  }
+
+  it: "is equal to another set" with: '== when: {
+    s1 = Set new
+    s2 = Set new
+    s1 == s2 is: true
+
+    s1 = Set[[1,2,3]]
+    s2 = Set[[3,2,1]]
+    s3 = Set[[3,1,2]]
+    s1 == s2 is: true
+    s1 == s3 is: true
+    s2 == s1 is: true
+    s2 == s3 is: true
+    s3 == s1 is: true
+    s3 == s2 is: true
+
+    s1 << 1 # should have no effect
+    s2 << 3
+    s2 == s1 is: true
+  }
+
+  it: "includes a value" with: 'includes?: when: {
+    s = Set[[1,2,3,"foo", 'bar, 10.0, 10.1]]
+    s includes?: 1 . is: true
+    s includes?: 2 . is: true
+    s includes?: 3 . is: true
+    s includes?: "foo" . is: true
+    s includes?: 'bar . is: true
+    s includes?: 10.0 . is: true
+    s includes?: 10.1 . is: true
+    s includes?: 'hello . is: false
+    s includes?: nil . is: false
+  }
+
+  it: "calls a Block with each value" with: 'each: when: {
+    s = Set[[1,2,3,4]]
+    sum = 0
+    s each: |val| {
+      sum = sum + val
+      s includes?: val . is: true
+    }
+   sum is: (s sum)
+  }
+
+  it: "removes a value in the Set" with: 'remove: when: {
+    s = Set[(1,2,3)]
+    s remove: 2
+    s is: (Set[(1,3)])
+    s remove: 1
+    s is: (Set[[3]])
+    s remove: 3
+    s empty? . is: true
+  }
+
+  it: "returns the union of two sets" with: '+ when: {
+    s1 = Set[(1,2,3)]
+    s2 = Set[(3,4,5)]
+    s1 + s2 is: (Set[(1,2,3,4,5)])
+  }
+
+  it: "returns the difference of two sets" with: '- when: {
+    s1 = Set[(1,2,3)]
+    s2 = Set[(3,4,5)]
+    s1 - s2 is: (Set[(1,2)])
+  }
+
+  it: "returns the intersection of two sets" with: '& when: {
+    s1 = Set[(1,2,3)]
+    s2 = Set[(2,3,4,5)]
+    s1 & s2 is: (Set[(2,3)])
   }
 }

data/tests/stack.fy

@@ -1,13 +1,13 @@
 FancySpec describe: Stack with: {
-  it: "should be empty when created" for: '<< when: {
+  it: "is empty when created" with: '<< when: {
     s = Stack new
-    s empty? should == true
+    s empty? is: true
   }
 
-  it: "should return the last inserted element" for: 'pop when: {
+  it: "returns the last inserted element" with: 'pop when: {
     s = Stack new
     s push: 1
-    s pop should == 1
+    s pop is: 1
 
     objs = [1,2,3]
     objs each: |x| {
@@ -15,8 +15,17 @@ FancySpec describe: Stack with: {
     }
 
     objs reverse each: |x| {
-      s pop should == x
+      s pop is: x
     }
+  }
 
+  it: "calls a Block with each element, starting with the top of stack" with: 'each: when: {
+    s = Stack new
+    10 times: |i| { s << i }
+    val = 9
+    s each: |x| {
+      x is: val
+      val = val - 1
+    }
   }
 }

data/tests/string.fy

@@ -1,109 +1,163 @@
 FancySpec describe: String with: {
-  it: "should be the empty string on initialization" when: {
+  it: "is the empty string on initialization" when: {
     str = String new
-    str should == ""
+    str is: ""
   }
 
-  it: "should be the concatination of the strings" for: '+ when: {
+  it: "is the concatination of the strings" with: '+ when: {
     str1 = "hello "
     str2 = "world"
     str3 = "!"
-    str1 + str2 + str3 should == "hello world!"
+    str1 + str2 + str3 is: "hello world!"
   }
 
-  it: "should concatenate the argument's string value with a string" for: '++ when: {
-    "I'm " ++ 21 ++ " years old!" should == "I'm 21 years old!"
+  it: "concatenates the argument's string value with a string" with: '++ when: {
+    "I'm " ++ 21 ++ " years old!" is: "I'm 21 years old!"
   }
 
-  it: "should return the correct substring" for: 'from:to: when: {
-    "hello, world" from: 2 to: 5 . should == "llo,"
-    "hello, world"[[2,5]] . should == "llo,"
+  it: "returns the correct substring" with: 'from:to: when: {
+    "hello, world" from: 2 to: 5 . is: "llo,"
+    "hello, world"[[2,5]] . is: "llo,"
   }
 
-  it: "should return the upcased string" for: 'upcase when: {
-    "hello, world" upcase should == "HELLO, WORLD"
+  it: "returns the upcased string" with: 'upcase when: {
+    "hello, world" upcase is: "HELLO, WORLD"
   }
 
-  it: "should return the downcased string" for: 'downcase when: {
-    "HELLO, WORLD" downcase should == "hello, world"
+  it: "returns the downcased string" with: 'downcase when: {
+    "HELLO, WORLD" downcase is: "hello, world"
   }
 
-  it: "should return the same string by down- and upcasing in a row" when: {
-    "HELLO, WORLD" downcase upcase should == "HELLO, WORLD"
+  it: "returns the same string by down- and upcasing in a row" when: {
+    "HELLO, WORLD" downcase upcase is: "HELLO, WORLD"
   }
 
-  it: "should iterate over each character in a string" for: 'each: when: {
+  it: "iterates over each character in a string" with: 'each: when: {
     str = "Hello, World!"
     i = 0
     str each: |char| {
-      char should == (str at: i)
+      char is: (str at: i)
       i = i + 1
     }
   }
 
-  it: "should behave like a collection/sequence via each:" for: 'uniq when: {
+  it: "behaves like a collection/sequence via each:" with: 'uniq when: {
     str = "Hello, World!"
-    str uniq join: "" . should == "Helo, Wrd!"
+    str uniq join: "" . is: "Helo, Wrd!"
   }
 
-  it: "should have all its characters as instances of String class" for: 'all?: when: {
+  it: "has all its characters as instances of String class" with: 'all?: when: {
     str = "foo bar baz"
-    str all?: |c| { c is_a?: String } . should == true
+    str all?: |c| { c is_a?: String } . is: true
   }
 
-  # it: "should drop all characters upto a whitespace" for: 'drop_while: when: {
-  #   "hello world" drop_while: |c| { c != " " } . join: "" . should == " world"
-  # }
+  it: "drops all characters upto a whitespace" with: 'drop_while: when: {
+    "hello world" drop_while: |c| { c != " " } . join: "" . is: " world"
+  }
 
-  it: "should be empty" for: 'empty? when: {
-    "" empty? should == true
-    " " empty? should == false
-    String new empty? should == true
+  it: "is empty" with: 'empty? when: {
+    "" empty? is: true
+    " " empty? is: false
+    String new empty? is: true
   }
 
-  # it: "should be blank" for: 'blank? when: {
-  #   "" blank? should == true
-  #   " " blank? should == true
-  #   "-" blank? should == false
-  #   "       " blank? should == true
-  #   "hello world" blank? should == false
-  #   "hello world" at: 5 . blank? should == true
-  # }
+  it: "is blank" with: 'blank? when: {
+    "" blank? is: true
+    " " blank? is: true
+    "-" blank? is: false
+    "       " blank? is: true
+    "hello world" blank? is: false
+    "hello world" at: 5 . blank? is: true
+  }
 
-  # it: "should be evaled as fancy code and return the correct value" when: {
-  #   x = "'foo" eval
-  #   x should == 'foo
-  #   "3 + 4" eval should == 7
-  #   "'foo to_s upcase" eval should == "FOO"
-  #   "33.33" eval should == 33.33
-  # }
+  it: "is evaluated as fancy code and returns the correct value" when: {
+    x = "'foo" eval
+    x is: 'foo
+    "3 + 4" eval is: 7
+    "'foo to_s upcase" eval is: "FOO"
+    "33.33" eval is: 33.33
+  }
 
-  it: "should return itself times n" for: '* when: {
-    "foo" * 2 should == "foofoo"
-    "f" ++ ("o" * 2) ++ "bar" should == "foobar"
+  it: "returns itself times n" with: '* when: {
+    "foo" * 2 is: "foofoo"
+    "f" ++ ("o" * 2) ++ "bar" is: "foobar"
   }
 
-  it: "should split a string at a given seperator string" for: 'split: when: {
+  it: "splits a string at a given seperator string" with: 'split: when: {
     str = "hello, world, how are you?"
-    str split: ", " . should == ["hello", "world", "how are you?"]
-    "1,2,3,,4,5" split: "," . should == ["1", "2", "3", "", "4", "5"]
-    ",1,2,3,4," split: "," . should == ["", "1", "2", "3", "4"]
-    "foo bar\n baz yo" split should == ["foo", "bar", "baz", "yo"]
-    "foo bar\n baz yo" words should == ["foo", "bar", "baz", "yo"]
+    str split: ", " . is: ["hello", "world", "how are you?"]
+    "1,2,3,,4,5" split: "," . is: ["1", "2", "3", "", "4", "5"]
+    ",1,2,3,4," split: "," . is: ["", "1", "2", "3", "4"]
+    "foo bar\n baz yo" split is: ["foo", "bar", "baz", "yo"]
+    "foo bar\n baz yo" words is: ["foo", "bar", "baz", "yo"]
   }
 
-  it: "should support basic string interpolation" when: {
-    "hello, #{10 * 10} world!" should == "hello, 100 world!"
+  it: "supports basic string interpolation" when: {
+    "hello, #{10 * 10} world!" is: "hello, 100 world!"
     x = "world"
-    "hello, #{x}!!" should == "hello, world!!"
+    "hello, #{x}!!" is: "hello, world!!"
+
+    "hello, #{x}, Fancy #{'rocks to_s upcase}!!" is: "hello, world, Fancy ROCKS!!"
+  }
+
+  it: "returns the String as a Symbol" with: 'to_sym when: {
+    "foo" to_sym is: 'foo
+    "foo:bar:" to_sym is: 'foo:bar:
+    "FooBar?!" to_sym is: 'FooBar?!
+    "+-&/^\?a!" to_sym is '+-&/^\?a!
+  }
+
+  it: "allows replacing characters in the string" with: '[]: when: {
+    s = "hello"
+    s[0]: "H"
+    s is: "Hello"
+    s[0]: "Good day. H"
+    s is: "Good day. Hello"
+    s[-1]: "o."
+    s is: "Good day. Hello."
+  }
+
+  it: "contains a substring" with: 'includes?: when: {
+    "foo bar baz" includes?: "foo" . is: true
+    "foo bar baz" includes?: "bar" . is: true
+    "foo bar baz" includes?: "baz" . is: true
+    "foo bar baz" includes?: " " . is: true
+    "foo bar baz" includes?: "" . is: true
+    "foo bar baz" includes?: "foobarbaz" . is: false
+  }
+
+  it: "should remove any leading indentation" with: 'skip_leading_indentation when: {
+    """
+    hello, world!
+    how are you?
+    """ skip_leading_indentation is: "hello, world!\nhow are you?"
+
+    str = """
+    foo, bar
+    """
+    str skip_leading_indentation is_not: str
+  }
+
+  it: "returns an array of all its characters" with: 'characters when: {
+    "foo" characters is: ["f","o","o"]
+    "" characters is: []
+    "f" characters is: ["f"]
+  }
+
+  it: "returns its first character as a fixnum ascii value" with: 'character when: {
+    "A" character is: 65
+    "a" character is: 97
+    "ab" character is: $ "a" character
+    "" character is: nil
+  }
 
-    "hello, #{x}, Fancy #{'rocks to_s upcase}!!" should == "hello, world, Fancy ROCKS!!"
+  it: "returns an enumerator for its all bytes (fixnum ascii values)" with: 'bytes when: {
+    "foo" bytes class is: FancyEnumerator
+    "" bytes class is: FancyEnumerator
   }
 
-  it: "should return the String as a Symbol" for: 'to_sym when: {
-    "foo" to_sym should == 'foo
-    "foo:bar:" to_sym should == 'foo:bar:
-    "FooBar?!" to_sym should == 'FooBar?!
-    "+-&/^\?a!" to_sym should '+-&/^\?a!
+  it: "returns a joined string using FancyEnumerable#join:" for: 'join: when: {
+    "foobar" join: "-" . is: "f-o-o-b-a-r"
+    "" join: "-" . is: ""
   }
 }