fancy 0.3.0

data/tests/control_flow.fy

@@ -0,0 +1,79 @@
+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: "should work like if_true:" for: 'if:then: when: {
+    if: (4 < 5) then: {
+      4 < 5 should == true
+    }
+  }
+
+  it: "should work like if_true:else: " for: 'if:then:else: when: {
+    if: (4 < 5) then: {
+      4 < 5 should == true
+    } else: {
+      4 < 5 should == nil
+    }
+  }
+
+  it: "should work like while_true:" for: 'while:do: when: {
+    x = 0
+    while: { x < 10 } do: {
+      x < 10 should == true
+      x = x + 1
+    }
+    x == 10 should == true
+  }
+
+  it: "should work like while_false: " for: 'until:do: when: {
+    x = 0
+    until: { x == 10 } do: {
+      x < 10 should == true
+      x = x + 1
+    }
+    x == 10 should == true
+  }
+
+  it: "should work like if_false:: " for: 'unless:do: when: {
+    unless: (4 > 5) do: {
+      5 > 4 should == true
+    }
+  }
+
+  it: "should only call the block if it's a true-ish value" for: 'if_do: when: {
+    1 if_do: |num| {
+      num * 10
+    } . should == 10
+
+    nil if_do: {
+      "nope"
+    } . should == nil
+
+    false if_do: {
+      "nope again"
+    } . should == nil
+  }
+
+  it: "should call the then_block if it's a true-ish value and call the else_block otherwise" for: 'if_do:else: when: {
+    1 if_do: |num| {
+      num * 10
+    } else: {
+      nil
+    } . should == 10
+
+    nil if_do: {
+      "nope"
+    } else: {
+      "yup"
+    } . should == "yup"
+
+    false if_do: {
+      "nope again"
+    } else: {
+      "yup again"
+    } . should == "yup again"
+  }
+}

data/tests/documentation.fy

@@ -0,0 +1,24 @@
+FancySpec describe: "Documentations" with: {
+  it: "should display 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
+  }
+
+  it: "should define a documenation string for a class and method" when: {
+    class ClassWithDoc {
+      "This class has a documentation! Yay!"
+      def foo {
+        "bar!"
+        nil
+      }
+    }
+    ClassWithDoc documentation should_not == ""
+    ClassWithDoc documentation should == "This class has a documentation! Yay!"
+    ClassWithDoc new method: 'foo . documentation docs should == ["bar!"]
+  }
+
+  it: "should have a documentation string for a method" when: {
+    Array new method: "first" . documentation should_not be: 'nil?
+  }
+}

data/tests/exception.fy

@@ -0,0 +1,115 @@
+class Foo {
+  def bar: x {
+    (x == 'error) . if_true: {
+      StdError new: "Some Error" . raise!
+    } else: {
+      'no_error
+    }
+  }
+}
+
+FancySpec describe: StdError with: {
+  it: "should raise an exception and catch it correctly" for: 'raise! when: {
+    try {
+      StdError new: "FAIL!" . raise!
+      nil should == true # this should not occur
+    } catch StdError => ex {
+      ex message should == "FAIL!"
+    }
+  }
+
+  it: "should raise an exception inside a method and catch it correctly" when: {
+    f = Foo new
+    f bar: "Don't raise here" . should == 'no_error
+    try {
+      f bar: 'error . should == 'no_error
+    } catch StdError => e {
+      e message should == "Some Error"
+    }
+  }
+
+  # it: "should raise a NoMethodError" when: {
+  #   s = 'symbol
+  #   try {
+  #     s this_method_doesnt_exist!
+  #     nil should == true # should not execute
+  #   } catch NoMethodError => err {
+  #     err for_class should == Symbol
+  #     err method_name should == "this_method_doesnt_exist!"
+  #   }
+  # }
+
+  it: "should have access to variables in exception handlers defined in the surrounding scope" when: {
+    var = 1234
+    try {
+      var wont_work!
+    } catch NoMethodError => err {
+      var should == 1234
+    }
+  }
+
+  it: "should always evaluate the finally clause" when: {
+    try {
+      x = 10 / 0 # ouch!
+      "This should fail!" should == true # should not get here!
+    } catch ZeroDivisionError => err {
+      err message should == "divided by 0"
+    } finally {
+      # this part gets always run :)
+      "It works!" should == "It works!"
+    }
+  }
+
+  it: "should raise a StdError when raising a String" for: 'raise! when: {
+    msg = "A Custom Error!"
+    try {
+      msg raise!
+      msg should_not == msg # this should not get executed
+    } catch StdError => e {
+      e message should == msg
+    }
+  }
+
+  # it: "should raise and catch a custom exception correctly" for: 'raise! when: {
+  #   class MyError : StdError{
+  #     def initialize {
+  #       super initialize: "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
+    x = 0
+    try {
+      x = 10 / y
+    } catch ZeroDivisionError => e {
+      y should == 0
+      x should == 0
+      y = 2
+      retry
+    }
+    y should  == 2
+    x should  == 5
+  }
+
+  it: "should always execute the finally block when defined" when: {
+    try {
+      msg = "Reraise a new Exception :P"
+      try {
+        10 / 0 # ZeroDivisionError
+      } finally {
+        msg raise!
+      }
+    } catch StdError => e {
+      e message should == msg
+    }
+  }
+}

data/tests/file.fy

@@ -0,0 +1,86 @@
+FancySpec describe: File with: {
+  it: "should return an array with the openmodes symbols" for: 'open:modes: when: {
+    file = File open: "README" modes: ['read]
+    file modes should == ['read]
+    file close
+  }
+
+  it: "should be open after opening it and closed after closing" for: 'close when: {
+    file = File open: "README" modes: ['read]
+    file open? should == true
+    file close
+    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 write and read from a file correctly" for: 'writeln: when: {
+    filename = "/tmp/read_write_test.txt"
+    file = File open: filename modes: ['write]
+    file writeln: "hello, world!"
+    file writeln: "line number two"
+    file close
+
+    File exists?: filename . should == true
+
+    file = File open: filename modes: ['read]
+    lines = []
+    2 times: {
+      lines << (file readln)
+    }
+    lines[0] should == "hello, world!\n"
+    lines[1] should == "line number two\n"
+    lines should == ["hello, world!\n", "line number two\n"]
+
+    # delete file
+    File delete: filename
+    File exists?: filename . should == false
+  }
+
+  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]
+    }
+  }
+
+  it: "should rename a File" when: {
+    dirname = "tmp/"
+    filename = dirname ++ "foobar"
+
+    Directory create: dirname
+
+    File open: filename  modes: ['write] with: |f| {
+      f writeln: "testing!"
+    }
+
+    Directory exists?: dirname . should == true
+    File exists?: dirname . should == true
+    File directory?: dirname . should == true
+
+    File rename: filename to: (filename ++ "-new")
+    File exists?: filename . should == false
+    File exists?: (filename ++ "-new") . should == true
+    File delete: (filename ++ "-new")
+    Directory delete: "tmp/"
+  }
+
+  it: "should be a directory" for: 'directory?: when: {
+    File directory?: "lib/" . should == true
+    File directory?: "lib/rbx" . should == true
+  }
+
+  it: "should NOT be a directory" for: 'directory?: when: {
+    File directory?: "src/Makefile" . should == false
+    File directory?: "README" . should == false
+    File directory?: "src/bootstrap/Makefile" . should == false
+  }
+}

data/tests/hash.fy

@@ -0,0 +1,101 @@
+FancySpec describe: Hash with: {
+  it: "should be empty on initialization" for: 'empty? when: {
+    hash = <[]>
+    hash size should == 0
+    hash empty? should == true
+  }
+
+  it: "should be empty on initialization via Hash#new" for: 'size when: {
+    hash = Hash new
+    hash size should == 0
+    hash empty? should == true
+  }
+
+  it: "should contain one entry" when: {
+    hash = <['foo => "bar"]>
+    hash size should == 1
+    hash empty? should == false
+  }
+
+  it: "should contain 10 square values after 10 insertions" for: 'at: when: {
+    hash = Hash new
+    10 times: |i| {
+      hash at: i put: (i * i)
+    }
+
+    10 times: |i| {
+      hash at: i . should == (i * i)
+    }
+  }
+
+  it: "should override the value for a given key" for: 'at: when: {
+    hash = <['foo => "bar"]>
+    hash at: 'foo . should == "bar"
+    hash at: 'foo put: 'foobarbaz
+    hash at: 'foo . should == 'foobarbaz
+  }
+
+  it: "should return all keys" for: 'keys when: {
+    hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
+    hash keys should =? ['foo, 'bar, 'foobar]
+  }
+
+  it: "should return all values" for: 'values when: {
+    hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
+    hash values should =? ["bar", "baz", 112.21]
+  }
+
+  it: "should return value by the []-operator" for: "[]" when: {
+    hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
+    hash['foo] should == "bar"
+    hash['bar] should == "baz"
+    hash['foobar] should == 112.21
+  }
+
+  it: "should call the Block for each key and value" for: 'each: when: {
+    hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
+    hash each: |key val| {
+      val should == (hash[key])
+    }
+  }
+
+  it: "should call the Block with each key" for: 'each_key: when: {
+    hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
+    count = 0
+    hash each_key: |key| {
+      key should == (hash keys[count])
+      count = count + 1
+    }
+  }
+
+  it: "should call the Block with each value" for: 'each_value: when: {
+    hash = <['foo => "bar", 'bar => "baz", 'foobar => 112.21]>
+    count = 0
+    hash each_value: |val| {
+      val should == (hash values[count])
+      count = count + 1
+    }
+  }
+
+  it: "should call most Enumerable methods with each pair" when: {
+    hash = <['hello => "world", 'fancy => "is cool"]>
+
+    hash map: |pair| { pair[0] } . should =? ['hello, 'fancy] # order does not matter
+
+    hash select: |pair| { pair[1] to_s includes?: "c" } .
+      should == [['fancy, "is cool"]]
+
+    hash reject: |pair| { pair[0] to_s includes?: "l" } .
+      map: 'second . should == ["is cool"]
+  }
+
+  it: "should return nil if the key isn't defined" when: {
+    <['foo => "bar"]> ['bar] . should == nil
+    <[]> ['foobar] . should == nil
+    <['foo => "bar"]> [nil] . should == nil
+  }
+
+  it: "should return an Array of the key-value pairs" when: {
+    <['foo => "bar", 'bar => "baz"]> to_a should =? [['foo, "bar"], ['bar, "baz"]]
+  }
+}

data/tests/method.fy

@@ -0,0 +1,131 @@
+FancySpec describe: Method with: {
+  it: "should return a Method object" when: {
+    [1,2,3] method: "each:" . class should == Method
+  }
+
+  # it: "should return the (correct) sender object of the MessageSend" when: {
+  #   class SenderTest {
+  #     def give_me_the_sender! {
+  #       __sender__
+  #     }
+  #   }
+
+  #   x = SenderTest new
+  #   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 {
+  #     }
+  #   }
+
+  #   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
+  # }
+
+  # it: "should return the return value" when: {
+  #   def foo: bar {
+  #     return "returning!"
+  #     bar # will never get executed
+  #   }
+
+  #   foo: "yay" . should == "returning!"
+
+  #   # another example
+
+  #   def f: x {
+  #     x < 10 if_true: {
+  #       return 100
+  #     }
+  #     0
+  #   }
+
+  #   f: 10 . should == 0
+  #   f: 9 . should == 100
+
+  #   # and another one
+
+  #   def foo {
+  #     10 times: |i| {
+  #       i == 8 if_true: {
+  #         return i # nested return
+  #       }
+  #     }
+  #     return 0
+  #   }
+
+  #   self foo should == 8
+  # }
+
+  it: "should return only from block-scope not from method-scope" when: {
+    def self foo {
+      10 times: |i| {
+        i == 8 if_true: {
+          return i
+        }
+      }
+      0
+    }
+    self 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]
+  # }
+
+  # 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 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 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 set the default values for optional argument, when not passed in" when: {
+    def foo: arg1 bar: arg2 ("foo") baz: arg3 (nil) {
+      arg1 ++ arg2 ++ arg3
+    }
+
+    foo: "hello" bar: "world" baz: "!" . should == "helloworld!"
+    foo: "hello" bar: "world" . should == "helloworld"
+    foo: "hello"  . should == "hellofoo"
+  }
+
+  it: "should return multiple values (as a Tuple)" when: {
+    def multiple_return_values: x {
+      (x, x + x, x + x + x)
+    }
+    val = multiple_return_values: 3 . should == (3, 6, 9)
+  }
+}