fancy 0.3.0

data/tests/nil_class.fy

@@ -0,0 +1,55 @@
+FancySpec describe: NilClass with: {
+  it: "should be false for calling and: with any value" for: 'and: when: {
+    nil and: true . should == false
+    nil and: 'foo . should == false
+    nil and: nil . should == false
+  }
+
+  it: "should be false for calling && with any value" for: '&& when: {
+    (nil && true) should == false
+    (nil && 'foo) should == false
+    (nil && nil) should == false
+  }
+
+  it: "should be true for calling or: with any non-nil value" for: 'or: when: {
+    nil or: true . should == true
+    nil or: 'foo . should == true
+  }
+
+  it: "should be nil for calling or: with a nil value" for: 'or: when: {
+    nil or: nil . should == false
+  }
+
+  it: "should be true for calling || with any non-nil value" for: '|| when: {
+    (nil || true) should == true
+    (nil || 'foo) should == true
+  }
+
+  it: "should be nil for calling || with a nil value" for: '|| when: {
+    (nil || nil) should == false
+  }
+
+  it: "should NOT call the block" for: 'if_true: when: {
+    nil if_true: { 'then } . should == nil
+  }
+
+  it: "should call the block" for: 'if_false: when: {
+    nil if_false: { 'false } . should == 'false
+  }
+
+  it: "should be nil" for: 'nil? when: {
+    nil nil? should == true
+  }
+
+  it: "should be false" for: 'false? when: {
+    nil false? should == true
+  }
+
+  it: "should NOT be true" for: 'true? when: {
+    nil true? should == false
+  }
+
+  it: "should call the block if nil" for: 'if_nil: when: {
+    nil if_nil: { 'is_nil } . should == 'is_nil
+  }
+}

data/tests/number.fy

@@ -0,0 +1,128 @@
+FancySpec describe: Number with: {
+  it: "should add two numbers correctly" for: '+ when: {
+    n1 = 20
+    n2 = 22
+    n1 + n2 should == 42
+  }
+
+  it: "should subtract two numbers correctly" for: '- when: {
+    n1 = 20
+    n2 = 22
+    n1 - n2 should == -2
+  }
+
+  it: "should multiply two numbers correctly" for: '* when: {
+    n1 = 20
+    n2 = 22
+    n1 * n2 should == 440
+  }
+
+  it: "should divide two numbers correctly" for: '/ when: {
+    n1 = 20
+    n2 = 10
+    n1 / n2 should == 2
+  }
+
+  it: "should raise an exception when dividing by zero" when: {
+    try {
+      10 / 0
+      "This should not happen!" should == nil
+    } catch ZeroDivisionError => err {
+      err message should == "divided by 0"
+    }
+  }
+
+  it: "should calculate the correct modulo value" for: 'modulo: when: {
+    9 % 4 should == 1
+    10 modulo: 2 . should == 0
+  }
+
+  it: "should do proper integer division" for: 'div: when: {
+    50 div: 10 . should == 5
+    55 div: 10 . should == 5
+    5 div: 10 . should == 0
+    ((55 div: 10) * 10) + (55 modulo: 10) should == 55
+  }
+
+  it: "should be the negation" for: 'negate when: {
+    42 negate should == -42
+  }
+
+  it: "should be odd" for: 'odd? when: {
+    1 odd? should == true
+    1 even? should == false
+  }
+
+  it: "should be even" for: 'even? when: {
+    2 odd? should == false
+    2 even? should == true
+  }
+
+  it: "should return an array from 0 upto 10" for: 'upto: when: {
+    0 upto: 10 . should == [0,1,2,3,4,5,6,7,8,9,10]
+  }
+
+  it: "should return an array from 10 downto 0" for: 'downto: when: {
+    10 downto: 0 . should == [10,9,8,7,6,5,4,3,2,1,0]
+  }
+
+  it: "should calculate the given power of itself" for: '** when: {
+    2 ** 3 should == 8
+    2 ** 0 should == 1
+    2 ** 1 should == 2
+    0 upto: 10 do_each: |i| {
+      i ** 0 should == 1
+      i ** 1 should == i
+      i ** 2 should == (i squared)
+    }
+  }
+
+  it: "should be the square of self" for: 'squared when: {
+    5 squared should == 25
+    10 squared should == 100
+    20 upto: 50 do_each: |i| {
+      i squared should == (i * i)
+    }
+  }
+
+  it: "should be the double value of self" for: 'doubled when: {
+    5 doubled should == 10
+    10 doubled should == 20
+    20 upto: 50 do_each: |i| {
+      i doubled should == (i + i)
+    }
+  }
+
+  it: "should be the same when using underscores within the literal" when: {
+    50000 should == 50_000
+    100_000 should == 100000
+    100_000 should == 100_000
+    100_000 should == 100000.0
+    100_000.0 should == 100000
+    100_999.999 should == 100999.999
+  }
+
+  it: "should evaluate octal literals correctly" when: {
+    0o00 should == 0
+    0o01 should == 1
+    0o07 should == 7
+    0o10 should == 8
+    0o70 should == 56
+  }
+
+  it: "should evaluate binary literals correctly" when: {
+    0b00 should == 0
+    0b01 should == 1
+    0b10 should == 2
+    0b11 should == 3
+    0b100 should == 4
+  }
+
+  it: "should evaluate hexadecimal literals correctly" when: {
+    0x00 should == 0
+    0x01 should == 1
+    0x0A should == 10
+    0xA0 should == 160
+    0xFF should == 255
+  }
+}

data/tests/object.fy

@@ -0,0 +1,125 @@
+FancySpec describe: Object with: {
+  it: "should dynamically evaluate a message-send with no arguments" when: {
+    obj = 42
+    obj send: "to_s" . should == "42"
+  }
+
+  it: "should dynamically evaluate a message-send with a list of arguments" when: {
+    obj = "hello, world"
+    obj send: "from:to:" params: [0,4] . should == "hello"
+  }
+
+  it: "should dynamically define slotvalues" when: {
+    obj = Object new
+    obj get_slot: 'foo . should == nil
+    obj set_slot: 'foo value: "hello, world"
+    obj get_slot: 'foo . should == "hello, world"
+  }
+
+  it: "should undefine a singleton method" when: {
+    def self a_singleton_method {
+      "a singleton method!"
+    }
+    self a_singleton_method should == "a singleton method!"
+    self undefine_singleton_method: 'a_singleton_method
+    try {
+      self a_singleton_method should == nil # should not get here
+    } catch NoMethodError => e {
+      e method_name should == "a_singleton_method"
+    }
+  }
+
+  it: "should return its class" when: {
+    nil class should == NilClass
+    true class should == TrueClass
+    "foo" class should == String
+    'bar class should == Symbol
+    { 'a_block } class should == Block
+  }
+
+  it: "should call unkown_message:with_params: when calling an undefined method" when: {
+    class UnknownMessage {
+      def unknown_message: message with_params: params {
+        "Got: " ++ message ++ " " ++ params
+      }
+    }
+
+    obj = UnknownMessage new
+    obj this_is_not_defined: "It's true!" . should == "Got: this_is_not_defined: It's true!"
+  }
+
+  it: "should return a correct string representation" when: {
+    3 to_s should == "3"
+    'foo to_s should == "foo"
+    nil to_s should == ""
+  }
+
+  it: "should return a correct array representation" when: {
+    nil to_a should == []
+    'foo to_a should == ['foo]
+    <['foo => "bar", 'bar => "baz"]> to_a should =? [['bar, "baz"], ['foo, "bar"]]
+  }
+
+  it: "should return a correct fixnum representation" when: {
+    nil to_i should == 0
+    3 to_i should == 3
+    3.28437 to_i should == 3
+  }
+
+  it: "should be an Object of the correct Class (or Superclass)" when: {
+    Object new is_a?: Object . should == true
+    "foo" is_a?: String . should == true
+    "foo" is_a?: Object . should == true
+    1123 is_a?: Fixnum . should == true
+    1123 is_a?: Object . should == true
+    132.123 is_a?: Float . should == true
+    132.123 is_a?: Object . should == true
+  }
+
+  # boolean messages
+
+  it: "should be true for calling and: with non-nil values" for: 'and: when: {
+    'foo and: 'bar . should == true
+  }
+
+  it: "should be false for calling and: with a nil value" for: 'and: when: {
+    'foo and: nil . should == false
+  }
+
+  it: "should be true for calling && with non-nil values" for: '&& when: {
+    ('foo && 'bar) should == true
+  }
+
+  it: "should be false for calling && with a nil value" for: '&& when: {
+    ('foo && nil) should == false
+  }
+
+
+  it: "should be true for calling or: with any value" for: 'or: when: {
+    'foo or: 'bar . should == true
+    'foo or: nil . should == true
+  }
+
+  it: "should be true for calling || with any value" for: '|| when: {
+    ('foo || 'bar) should == true
+    ('foo || nil) should == true
+  }
+
+  # end boolean messages
+
+  it: "should NOT be nil for non-nil values" for: 'nil? when: {
+    'foo nil? should == nil
+    1 nil? should == nil
+    "hello" nil? should == nil
+  }
+
+  it: "should NOT be false for non-nil values" for: 'false? when: {
+    'foo false? should == nil
+    "hello, world" false? should == nil
+  }
+
+  it: "should not be true" for: 'true? when: {
+    'foo true? should == nil
+    "hello, world" true? should == nil
+  }
+}

data/tests/parsing/sexp.fy

@@ -0,0 +1,50 @@
+FancySpec describe: "S-Expression" for: String with: {
+  it: "should be correct for assignment" for: 'to_sexp when: {
+    "x = 3" to_sexp should == ['exp_list, [['assign, ['ident, 'x], ['int_lit, 3]]]]
+    "foobar = nil" to_sexp should == ['exp_list, [['assign, ['ident, 'foobar], ['ident, 'nil]]]]
+  }
+
+  it: "should be correct for symbol literals" for: 'to_sexp when: {
+    "'foo" to_sexp should == ['exp_list, [['symbol_lit, 'foo]]]
+  }
+
+  it: "should be correct for string literals" for: 'to_sexp when: {
+    #    "\"foo\"" to_sexp should == ['exp_list, [['string_lit, "foo"]]
+  }
+
+  it: "should be correct for integer literals" for: 'to_sexp when: {
+    "3" to_sexp should == ['exp_list, [['int_lit, 3]]]
+    "-3" to_sexp should == ['exp_list, [['int_lit, -3]]]
+    "0" to_sexp should == ['exp_list, [['int_lit, 0]]]
+  }
+
+  it: "should be correct for double literals" for: 'to_sexp when: {
+    "3.5" to_sexp should == ['exp_list, [['double_lit, 3.5]]]
+    "-3.5" to_sexp should == ['exp_list, [['double_lit, -3.5]]]
+    "0.0" to_sexp should == ['exp_list, [['double_lit, 0.0]]]
+  }
+
+  it: "should be correct for array literals" for: 'to_sexp when: {
+    "[1,2,3]" to_sexp should == ['exp_list, [['array_lit, [['int_lit, 1], ['int_lit, 2], ['int_lit, 3]]]]]
+
+    "[[1,2],[3,4]]" to_sexp should == .
+    ['exp_list, [['array_lit, [['array_lit, [['int_lit, 1], ['int_lit, 2]]],
+                               ['array_lit, [['int_lit, 3], ['int_lit, 4]]]]]]]
+
+    "[]" to_sexp should == ['exp_list, [['array_lit, []]]]
+  }
+
+  it: "should be able to parse multiple expressions in one string" for: 'to_sexp when: {
+    "x = 1; y = 2" to_sexp should == ['exp_list, [['assign, ['ident, 'x], ['int_lit, 1]],
+                                                  ['assign, ['ident, 'y], ['int_lit, 2]]]]
+  }
+
+  it: "should parse an RubyArgsLiteral correctly" for: 'to_sexp when: {
+    "obj foo: ~[1,2]" to_sexp should == .
+    ['exp_list, [['message_send, ['ident, 'obj],
+                  ['ident, 'foo:],
+                  [['rb_args_lit, ['array_lit,
+                                   [['int_lit, 1],
+                                    ['int_lit, 2]]]]]]]]
+  }
+}

data/tests/pattern_matching.fy

@@ -0,0 +1,82 @@
+FancySpec describe: "Pattern Matching" with: {
+  it: "should match a value correctly by its class" when: {
+    def do_match: obj {
+      match obj -> {
+        case String -> 'string
+        case Fixnum -> 'fixnum
+        case _ -> 'anything
+      }
+    }
+
+    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
+  }
+
+  it: "should bind 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"
+    }
+  }
+
+  it: "should only bind 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 should == nil
+  }
+
+  it: "should only bind 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 should == nil
+  }
+
+  it: "should bind 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"
+    }
+  }
+
+  it: "should return an instance of the apropriate MatchData class" when: {
+    def create_tuple: num {
+      (num, num * num) # create a Tuple
+    }
+
+    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
+    }
+  }
+
+  it: "should match 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)
+    }
+  }
+}

data/tests/range.fy

@@ -0,0 +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: "should have a working literal syntax" when: {
+    (1..10) should == (Range new: 1 to: 10)
+  }
+}