fancy 0.3.2 → 0.3.3

data/tests/block.fy

@@ -139,4 +139,48 @@ FancySpec describe: Block with: {
     b receiver: "Hello, World!"
     b receiver should == "Hello, World!"
   }
+
+  it: "should call a block with a different receiver" for: 'call_with_receiver when: {
+    class ClassA {
+      def inspect {
+        "in ClassA#inspect"
+      }
+    }
+    class ClassB {
+      def inspect {
+        "in ClassB#inspect"
+      }
+    }
+    def self inspect {
+      "in self#inspect"
+    }
+    block = {
+      self inspect
+    }
+    block call should == "in self#inspect"
+    block call_with_receiver: (ClassA new) . should == "in ClassA#inspect"
+    block call_with_receiver: (ClassB new) . should == "in ClassB#inspect"
+  }
+
+  it: "should call a block with arguments and a different receiver" for: 'call:with_receiver: when: {
+    class ClassC {
+      def inspect: x {
+        "in ClassC#inspect: #{x}"
+      }
+    }
+    class ClassD {
+      def inspect: x {
+        "in ClassD#inspect: #{x}"
+      }
+    }
+    def self inspect: x {
+      "in self#inspect: #{x}"
+    }
+    block = |arg| {
+      self inspect: arg
+    }
+    block call: [42] . should == "in self#inspect: 42"
+    block call: [42] with_receiver: (ClassC new) . should == "in ClassC#inspect: 42"
+    block call: [42] with_receiver: (ClassD new) . should == "in ClassD#inspect: 42"
+  }
 }

data/tests/class.fy

@@ -172,34 +172,34 @@ FancySpec describe: Class with: {
     instance foo: "Test!" . should == "In AClass#foo: with bar = Test!"
   }
 
-  # it: "should call superclass method by calling super" when: {
-  #   class SuperClass {
-  #     read_slots: ['name]
-  #     def initialize: name {
-  #       @name = name
-  #     }
-  #   }
-  #   class SubClass : SuperClass {
-  #     read_slots: ['age]
+  it: "should call superclass method by using super" when: {
+    class SuperClass {
+      read_slots: ['name]
+      def initialize: name {
+        @name = name
+      }
+    }
+    class SubClass : SuperClass {
+      read_slots: ['age]
 
-  #     def initialize: age {
-  #       super initialize: "SubClass"
-  #       @age = age
-  #     }
-  #     def initialize {
-  #       super initialize: "SubClass"
-  #       @age = 0
-  #     }
-  #   }
+      def initialize: age {
+        super initialize: "SubClass"
+        @age = age
+      }
+
+      def initialize {
+        initialize: 0
+      }
+    }
 
-  #   sub = SubClass new: 42
-  #   sub name should == "SubClass"
-  #   sub age should == 42
+    sub = SubClass new: 42
+    sub name should == "SubClass"
+    sub age should == 42
 
-  #   sub2 = SubClass new
-  #   sub2 name should == "SubClass"
-  #   sub2 age should == 0
-  # }
+    sub2 = SubClass new
+    sub2 name should == "SubClass"
+    sub2 age should == 0
+  }
 
   it: "should return its superclass" when: {
     Fixnum superclass should == Integer
@@ -212,19 +212,19 @@ FancySpec describe: Class with: {
     NoMethodError superclass should == NameError
   }
 
-  # it: "should create a new Class dynamically" when: {
-  #   x = Class new
-  #   x is_a?: Class . should == true
-  #   x new is_a?: x . should == true
-  #   x new is_a?: Object . should == true
-  #   x new class should == x
-
-  #   # Symbol as superclass
-  #   y = Class new: Symbol
-  #   y is_a?: Class . should == true
-  #   y new is_a?: Symbol . should == true
-  #   y new is_a?: Object . should == true
-  # }
+  it: "should create a new Class dynamically" when: {
+    x = Class new
+    x is_a?: Class . should == true
+    x new is_a?: x . should == true
+    x new is_a?: Object . should == true
+    x new class should == x
+
+    # Symbol as superclass
+    y = Class new: String
+    y is_a?: Class . should == true
+    y new is_a?: String . should == true
+    # y new is_a?: Object . should == true
+  }
 
   it: "should only be able to call the public method from outside the Class" when: {
     x = ClassWithPrivate new
@@ -232,12 +232,12 @@ FancySpec describe: Class with: {
     try {
       x private_method should == nil # should fail
     } catch NoMethodError => e {
-      e method_name should == "private_method"
+      e method_name should == 'private_method
     }
     try {
       x protected_method should == nil # should fail
     } catch NoMethodError => e {
-      e method_name should == "protected_method"
+      e method_name should == 'protected_method
     }
   }
 
@@ -253,28 +253,28 @@ FancySpec describe: Class with: {
     Super subclass?: Sub . should == nil
   }
 
-  # it: "should dynamically create a subclass of another class" for: 'is_a?: when: {
-  #   subclass = String subclass: {
-  #     def foo {
-  #       "hello, world!"
-  #     }
-  #   }
-  #   subclass is_a?: Class . should == true
-  #   subclass subclass?: String . should == true
-  #   subclass new is_a?: subclass . should == true
-  #   subclass new foo should == "hello, world!"
-
-  #   # now the same with Class##new:body:
-  #   subclass2 = Class superclass: Symbol body: {
-  #     def foo {
-  #       "hello, world, again!"
-  #     }
-  #   }
-  #   subclass2 is_a?: Class . should == true
-  #   subclass2 subclass?: String . should == true
-  #   subclass2 new is_a?: subclass2 . should == true
-  #   subclass2 new foo should == "hello, world, again!"
-  # }
+  it: "should dynamically create a subclass of another class" for: 'is_a?: when: {
+    subclass = String subclass: {
+      def foo {
+        "hello, world!"
+      }
+    }
+    subclass is_a?: Class . should == true
+    subclass subclass?: String . should == true
+    subclass new is_a?: subclass . should == true
+    subclass new foo should == "hello, world!"
+
+    # now the same with Class##new:body:
+    subclass2 = Class superclass: String body: {
+      def foo {
+        "hello, world, again!"
+      }
+    }
+    subclass2 is_a?: Class . should == true
+    subclass2 subclass?: String . should == true
+    subclass2 new is_a?: subclass2 . should == true
+    subclass2 new foo should == "hello, world, again!"
+  }
 
   it: "should undefine an instance method" for: 'undefine_method: when: {
     class Foo {
@@ -288,7 +288,7 @@ FancySpec describe: Class with: {
     try {
       f instance_method should == nil # should not get here
     } catch NoMethodError => e {
-      e method_name should == "instance_method"
+      e method_name should == 'instance_method
     }
   }
 
@@ -312,34 +312,34 @@ FancySpec describe: Class with: {
     try {
       Foo class_method should == nil # should not get here
     } catch NoMethodError => e {
-      e method_name should == "class_method"
+      e method_name should == 'class_method
     }
   }
 
-  # it: "should have nested classes" when: {
-  #   class Outer {
-  #     class Inner {
-  #       class InnerMost {
-  #         def foobar {
-  #           "foobar!"
-  #         }
-  #       }
-  #     }
-  #   }
-  #   Outer is_a?: Class . should == true
-  #   Outer::Inner is_a?: Class . should == true
-  #   Outer::Inner::InnerMost is_a?: Class . should == true
-  #   obj = Outer::Inner::InnerMost new
-  #   obj foobar should == "foobar!"
-
-  #   # change InnerMost#foobar
-  #   class Outer::Inner::InnerMost {
-  #     def foobar {
-  #       "oh no!"
-  #     }
-  #   }
-  #   obj foobar . should == "oh no!"
-  # }
+  it: "should have nested classes" when: {
+    class Outer {
+      class Inner {
+        class InnerMost {
+          def foobar {
+            "foobar!"
+          }
+        }
+      }
+    }
+    Outer is_a?: Class . should == true
+    Outer::Inner is_a?: Class . should == true
+    Outer::Inner::InnerMost is_a?: Class . should == true
+    obj = Outer::Inner::InnerMost new
+    obj foobar should == "foobar!"
+
+    # change InnerMost#foobar
+    class Outer::Inner::InnerMost {
+      def foobar {
+        "oh no!"
+      }
+    }
+    obj foobar . should == "oh no!"
+  }
 
   it: "should not override existing classes with the same name in a nested class" when: {
     StdArray = Array
@@ -433,6 +433,20 @@ FancySpec describe: Class with: {
     obj bar should == "in foo!"
   }
 
+  it: "should have an alias method for a ruby method defined" for: 'alias_method:for_ruby: when: {
+    try {
+      [] equal?: [1,2] . should == true # should fail
+    } catch NoMethodError => e {
+      e method_name should == 'equal?:
+    }
+
+    class Array {
+      alias_method: 'equal?: for_ruby: 'equal?
+    }
+
+    [] equal?: [1,2] . should == false
+  }
+
   it: "should have the correct list of ancestors" for: 'ancestors when: {
     class A {
     }

data/tests/control_flow.fy

@@ -43,37 +43,160 @@ FancySpec describe: "Control Flow" with: {
     }
   }
 
-  it: "should only call the block if it's a true-ish value" for: 'if_do: when: {
-    1 if_do: |num| {
+  it: "should only call the block if it's a true-ish value" for: 'if_true: when: {
+    1 if_true: |num| {
       num * 10
     } . should == 10
 
-    nil if_do: {
+    nil if_true: {
       "nope"
     } . should == nil
 
-    false if_do: {
+    false if_true: {
       "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| {
+  it: "should call the then_block if it's a true-ish value and call the else_block otherwise" for: 'if_true:else: when: {
+    1 if_true: |num| {
       num * 10
     } else: {
       nil
     } . should == 10
 
-    nil if_do: {
+    nil if_true: {
       "nope"
     } else: {
       "yup"
     } . should == "yup"
 
-    false if_do: {
+    false if_true: {
       "nope again"
     } else: {
       "yup again"
     } . should == "yup again"
   }
+
+  it: "should be possible to override the if_true:else: method and work accordingly in conditionals" when: {
+    class AClasThatIsLikeFalse {
+      def if_true: block else: another_block {
+        another_block call
+      }
+    }
+
+    obj = AClasThatIsLikeFalse new
+    if: obj then: {
+      'fail
+    } else: {
+      'success
+    } . should == 'success
+
+    # let's get rid of this custom if_true:else: method
+    AClasThatIsLikeFalse undefine_method: 'if_true:else:
+
+    if: obj then: {
+      'now_this_is_success
+    } else: {
+      'fail
+    } . should == 'now_this_is_success
+  }
+
+  it: "should break from an iteration" for: 'break when: {
+    x = 0
+    until: { x == 10 } do: {
+      x = x + 1
+      { break } if: (x == 5)
+    }
+    x == 5 should == true
+  }
+
+  it: "should break from an iteration with return value" for: 'break: when: {
+    x = 0
+    y = until: { x == 10 } do: {
+      x = x + 1
+      { break: 42 } if: (x == 5)
+    }
+
+    x should == 5
+    y should == 42
+  }
+
+  it: "should skip an iteration over a Range" for: 'next when: {
+    total = 0
+    (1..10) each: |i| {
+      { next } if: (i == 5)
+      total = total + i
+    }
+    total should == 50
+  }
+
+  it: "should skip an iteration over an Array" for: 'next when: {
+    total = 0
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] each: |i| {
+      { next } if: (i == 5)
+      total = total + i
+    }
+    total should == 50
+  }
+
+  it: "should skip an iteration over an Hash" for: 'next when: {
+    total = 0
+    <['a => 1, 'b => 2, 'c => 3, 'd => 4, 'e => 5, 'f => 6]> each: |k v| {
+      { next } if: (k == 'd)
+      total = total + v
+    }
+    total should == 17
+  }
+
+  it: "stops any loop type at the correct spot" for: 'break when: {
+    i = 0
+    loop: {
+      { break } if: (i == 3)
+      i = i + 1
+    }
+    i should == 3
+
+    i = 0
+    while: { i < 5 } do: {
+      { break } if: (i == 3)
+      i = i + 1
+    }
+    i should == 3
+
+    i = 0
+    0 upto: 5 do: |n| {
+      i = n
+      { break } if: (n == 3)
+    }
+    i should == 3
+  }
+
+  it: "stops any loop type at the correct spot" for: 'break: when: {
+    i = 0
+    loop: {
+      { break: i } if: (i == 2)
+      i = i + 1
+    } . should == 2
+
+    i = 0
+    while: { i < 5 } do: {
+      { break: i } if: (i == 2)
+      i = i + 1
+    } . should == 2
+
+    i = 0
+    0 upto: 5 do: |n| {
+      i = n
+      { break: n } if: (n == 2)
+    }
+    i should == 2
+  }
+
+  it: "should allow empty try blocks" when: {
+    x = "foo"
+    try {
+    } finally {
+      x should == "foo"
+    }
+  }
 }