fancy 0.3.3 → 0.4.0

data/tests/assignment.fy

@@ -1,53 +1,53 @@
 FancySpec describe: "Assignment" with: {
-  it: "should correctly assign multiple values at once" when: {
+  it: "correctly assigns multiple values at once" when: {
     x, y, z = 1, 10, 100
-    x should == 1
-    y should == 10
-    z should == 100
+    x is: 1
+    y is: 10
+    z is: 100
 
     x, y, z = 'foo, 'bar
-    x should == 'foo
-    y should == 'bar
-    z should == nil
+    x is: 'foo
+    y is: 'bar
+    z is: nil
 
     x = 'foo
     y = 'bar
     x, y = y, x
-    x should == 'bar
-    y should == 'foo
+    x is: 'bar
+    y is: 'foo
   }
 
-  it: "should handle multiple assignment for any collection type implementing 'at:" when: {
+  it: "handles multiple assignment for any collection type implementing 'at:" when: {
     x, y, z = (1, 2, 3)
-    x should == 1
-    y should == 2
-    z should == 3
+    x is: 1
+    y is: 2
+    z is: 3
 
     a, b, c = ["a", "b", "c"]
-    a should == "a"
-    b should == "b"
-    c should == "c"
+    a is: "a"
+    b is: "b"
+    c is: "c"
 
     e, f = ([1,2], "foo")
-    e should == [1,2]
-    f should == "foo"
+    e is: [1,2]
+    f is: "foo"
   }
 
-  it: "should handle multiple assignment with splat-identifiers" when: {
+  it: "handles multiple assignment with splat-identifiers" when: {
     x,y,z,*rest = [1,2,3,4,5,6,7]
-    x should == 1
-    y should == 2
-    z should == 3
-    rest should == [4,5,6,7]
+    x is: 1
+    y is: 2
+    z is: 3
+    rest is: [4,5,6,7]
 
     a,b,*c,*d,e = [1,2,3,4,5,6,7,8]
-    a should == 1
-    b should == 2
-    c should == [3,4,5,6,7,8]
-    d should == [4,5,6,7,8]
-    e should == 5
+    a is: 1
+    b is: 2
+    c is: [3,4,5,6,7,8]
+    d is: [4,5,6,7,8]
+    e is: 5
 
     _,_,*z = "hello, world!" # ignore first 2 characters
-    z should == "llo, world!"
+    z is: "llo, world!"
   }
 }

data/tests/block.fy

@@ -1,146 +1,146 @@
 FancySpec describe: Block with: {
-  it: "should return the value of the last expression" when: {
+  it: "returns the value of the last expression" when: {
     block = {
       a = "a"
       empty = " "
       str = "String!"
       a ++ empty ++ str
     }
-    block call should == "a String!"
+    block call is: "a String!"
   }
 
-  it: "should close over a value and change it internally" when: {
+  it: "closes over a value and change it internally" when: {
     x = 0
     { x < 10 } while_true: {
-      x should be: |x| { x < 10 }
+      x is be: |x| { x < 10 }
       x = x + 1
     }
-    x should == 10
+    x is: 10
   }
 
-  it: "should return the argument count" for: 'argcount when: {
-    { } argcount . should == 0
-    |x| { } argcount . should == 1
-    |x y z| { } argcount . should == 3
+  it: "returns the argument count" with: 'arity when: {
+    { } arity . is: 0
+    |x| { } arity . is: 1
+    |x y z| { } arity . is: 3
   }
 
-  it: "should call a block while another is true" for: 'while_true: when: {
+  it: "calls a block while another is true" with: 'while_true: when: {
     i = 0
     {i < 10} while_true: {
       i = i + 1
     }
-    i should be: { i >= 10 }
+    i is be: { i >= 10 }
   }
 
-  it: "should call a block while another is not true (boolean false)" for: 'while_false: when: {
+  it: "calls a block while another is not true (boolean false)" with: 'while_false: when: {
     i = 0
     {i == 10} while_false: {
       i = i + 1
     }
-    i should == 10
+    i is: 10
   }
 
   # again for while_nil
-  it: "should call a block while another is nil" for: 'while_nil: when: {
+  it: "calls a block while another is nil" with: 'while_nil: when: {
     i = 0
     {i == 10} while_nil: {
       i = i + 1
     }
-    i should == 10
+    i is: 10
   }
 
-  it: "should call a block while another one is true-ish" for: 'while_do: when: {
+  it: "calls a block while another one is true-ish" with: 'while_do: when: {
     x = 0
     { x < 10 } while_do: |val| {
-      val should == true
+      val is: true
       x = x + 1
     }
   }
 
-  it: "should call another block while a block yields false" for: 'until_do: when: {
+  it: "calls another block while a block yields false" with: 'until_do: when: {
     i = 0
-    { i > 10 } until_do: { i <= 10 should == true; i = i + 1 }
-    i should == 11
+    { i > 10 } until_do: { i <= 10 is: true; i = i + 1 }
+    i is: 11
   }
 
-  it: "should call a block until another yields true" for: 'until: when: {
+  it: "calls a block until another yields true" with: 'until: when: {
     i = 0
-    { i <= 10 should == true; i = i + 1 } until: { i > 10 }
-    i should == 11
+    { i <= 10 is: true; i = i + 1 } until: { i > 10 }
+    i is: 11
   }
 
-  it: "should call itself only when the argument is nil" for: 'unless: when: {
+  it: "calls itself only when the argument is nil" with: 'unless: when: {
     try {
       { StdError new: "got_run!" . raise! } unless: nil
       StdError new: "didnt_run!" . raise!
     } catch StdError => e {
-      e message should == "got_run!"
+      e message is: "got_run!"
     }
   }
 
-  it: "should call itself only when the argument is true" for: 'if: when: {
+  it: "calls itself only when the argument is true" with: 'if: when: {
     try {
       { StdError new: "got_run!" . raise! } if: true
       StdError new: "didnt_run!" . raise!
     } catch StdError => e {
-      e message should == "got_run!"
+      e message is: "got_run!"
     }
   }
 
-  it: "should also be able to take arguments seperated by comma" for: 'call: when: {
+  it: "also is able to take arguments seperated by comma" with: 'call: when: {
     block = |x, y| { x + y }
-    block call: [1,2] . should == 3
+    block call: [1,2] . is: 3
   }
 
-  it: "should evaluate the blocks in a short-circuiting manner" for: '&& when: {
-    { false } && { false } should == false
-    { true } && { false } should == false
-    { false } && { true } should == false
-    { true } && { true } should == true
+  it: "evaluates the blocks in a short-circuiting manner" with: '&& when: {
+    { false } && { false } is: false
+    { true } && { false } is: false
+    { false } && { true } is: false
+    { true } && { true } is: true
 
-    { false } || { false } should == false
-    { false } || { true } should == true
-    { true } || { false } should == true
-    { true } || { true } should == true
+    { false } || { false } is: false
+    { false } || { true } is: true
+    { true } || { false } is: true
+    { true } || { true } is: true
 
     # TODO: Add more useful tests here...
   }
 
-  it: "should call the block as a partial block" when: {
-    [1,2,3] map: @{upto: 3} . should == [[1,2,3], [2,3], [3]]
-    [1,2,3] map: @{+ 3} . should == [4,5,6]
-    [1,2,3] map: @{to_s} . should == ["1", "2", "3"]
-    [1,2,3] map: @{to_s * 3} . should == ["111", "222", "333"]
+  it: "calls the block as a partial block" when: {
+    [1,2,3] map: @{upto: 3} . is: [[1,2,3], [2,3], [3]]
+    [1,2,3] map: @{+ 3} . is: [4,5,6]
+    [1,2,3] map: @{to_s} . is: ["1", "2", "3"]
+    [1,2,3] map: @{to_s * 3} . is: ["111", "222", "333"]
   }
 
-  it: "should execute a match clause if the block returns a true-ish value" for: '=== when: {
+  it: "executes a match clause if the block returns a true-ish value" with: '=== when: {
     def do_match: val {
       match val {
         case |x| { x even? } -> "yup, it's even"
         case _ -> "nope, not even"
       }
     }
-    do_match: 2 . should == "yup, it's even"
-    do_match: 1 . should == "nope, not even"
+    do_match: 2 . is: "yup, it's even"
+    do_match: 1 . is: "nope, not even"
   }
 
-  it: "should return the receiver of a block" for: 'receiver when: {
+  it: "returns the receiver of a block" with: 'receiver when: {
     class Foo { def foo { { self } } } # return block
     f = Foo new
-    f foo receiver should == f
+    f foo receiver is: f
   }
 
-  it: "should set the receiver correctly to a new value" for: 'receiver: when: {
+  it: "sets the receiver correctly to a new value" with: 'receiver: when: {
     b = { "hey" }
 
     b receiver: 10
-    b receiver should == 10
+    b receiver is: 10
 
     b receiver: "Hello, World!"
-    b receiver should == "Hello, World!"
+    b receiver is: "Hello, World!"
   }
 
-  it: "should call a block with a different receiver" for: 'call_with_receiver when: {
+  it: "calls a block with a different receiver" with: 'call_with_receiver: when: {
     class ClassA {
       def inspect {
         "in ClassA#inspect"
@@ -157,12 +157,12 @@ FancySpec describe: Block with: {
     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"
+    block call is: "in self#inspect"
+    block call_with_receiver: (ClassA new) . is: "in ClassA#inspect"
+    block call_with_receiver: (ClassB new) . is: "in ClassB#inspect"
   }
 
-  it: "should call a block with arguments and a different receiver" for: 'call:with_receiver: when: {
+  it: "calls a block with arguments and a different receiver" with: 'call:with_receiver: when: {
     class ClassC {
       def inspect: x {
         "in ClassC#inspect: #{x}"
@@ -179,8 +179,21 @@ FancySpec describe: Block with: {
     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"
+    block call: [42] . is: "in self#inspect: 42"
+    block call: [42] with_receiver: (ClassC new) . is: "in ClassC#inspect: 42"
+    block call: [42] with_receiver: (ClassD new) . is: "in ClassD#inspect: 42"
+  }
+
+  it: "calls a block using the ruby-send syntax" with: 'call: when: {
+    b = |x y| {
+      x + y
+    }
+
+    b call: [2,3] . is: 5
+    b(2,3) . is: 5
+
+    b2 = |x| { x * 5 }
+    b2("hello") is: ("hello" * 5)
+    b2("foo") is: (b2 call: ["foo"])
   }
 }

data/tests/class.fy

@@ -25,98 +25,100 @@ class ClassWithPrivate {
     "public!"
   }
 
-  def protected protected_method {
+  def protected_method {
     "protected!"
   }
+  protected: 'protected_method
 
-  def private private_method {
+  def private_method {
     "private!"
   }
+  private: 'private_method
 }
 
 FancySpec describe: Class with: {
-  it: "should NOT find the method when not mixed-in" for: 'responds_to?: when: {
+  it: "does NOT find the method when not mixed-in" with: 'responds_to?: when: {
     instance = ClassWithMixin new
-    instance normal_method . should == 'normal_found
-    instance responds_to?: 'normal_method . should == true
-    instance responds_to?: 'mixin_method . should == false
+    instance normal_method . is: 'normal_found
+    instance responds_to?: 'normal_method . is: true
+    instance responds_to?: 'mixin_method . is: false
   }
 
-  it: "should find the method when mixed-in" for: 'include: when: {
+  it: "finds the method when mixed-in" with: 'include: when: {
     # => include Mixin into ClassWithMixin
     class ClassWithMixin {
       include: Mixin
     }
 
     instance = ClassWithMixin new
-    instance responds_to?: 'normal_method . should == true
-    instance responds_to?: 'mixin_method . should == true
-    instance normal_method . should == 'normal_found
-    instance mixin_method . should == 'mixed_in_found
+    instance responds_to?: 'normal_method . is: true
+    instance responds_to?: 'mixin_method . is: true
+    instance normal_method . is: 'normal_found
+    instance mixin_method . is: 'mixed_in_found
   }
 
-  it: "should rebind the old class name with ClassWithNoMixin and replace the old normal_method" when: {
+  it: "rebinds the old class name with ClassWithNoMixin and replace the old normal_method" when: {
     instance = ClassWithMixin new
-    instance normal_method should == 'normal_found
+    instance normal_method is: 'normal_found
     # rebind the class to the other class
     ClassWithMixin = ClassWithNoMixin
     instance = ClassWithMixin new
-    instance normal_method should == 'new_normal_found
+    instance normal_method is: 'new_normal_found
   }
 
-  it: "should have dynamically generated getter and setter methods" for: 'responds_to?: when: {
+  it: "has dynamically generated getter and setter methods" with: 'responds_to?: when: {
     instance = ClassWithNoMixin new
-    instance responds_to?: 'foo . should == true
-    instance responds_to?: 'bar . should == true
-    instance responds_to?: 'baz . should == true
-    instance responds_to?: "hello:" . should == true
-    instance responds_to?: "world:" . should == true
-    instance responds_to?: 'oh . should == true
-    instance responds_to?: ":oh" . should == true
-    instance responds_to?: 'noes . should == true
-    instance responds_to?: "noes:" . should == true
-  }
-
-  it: "should define getter methods for single slots" for: 'read_slot: when: {
+    instance responds_to?: 'foo . is: true
+    instance responds_to?: 'bar . is: true
+    instance responds_to?: 'baz . is: true
+    instance responds_to?: "hello:" . is: true
+    instance responds_to?: "world:" . is: true
+    instance responds_to?: 'oh . is: true
+    instance responds_to?: ":oh" . is: true
+    instance responds_to?: 'noes . is: true
+    instance responds_to?: "noes:" . is: true
+  }
+
+  it: "defines getter methods for single slots" with: 'read_slot: when: {
     class Getters {
       read_slot: 'foo
       read_slot: 'bar
     }
 
     g = Getters new
-    g responds_to?: 'foo . should == true
-    g responds_to?: 'foo: . should == false
-    g responds_to?: 'bar . should == true
-    g responds_to?: 'bar: . should == false
+    g responds_to?: 'foo . is: true
+    g responds_to?: 'foo: . is: false
+    g responds_to?: 'bar . is: true
+    g responds_to?: 'bar: . is: false
   }
 
-  it: "should define setter methods for single slots" for: 'write_slot: when: {
+  it: "defines setter methods for single slots" with: 'write_slot: when: {
     class Setters {
       write_slot: 'foo
       write_slot: 'bar
     }
 
     s = Setters new
-    s responds_to?: 'foo . should == false
-    s responds_to?: 'foo: . should == true
-    s responds_to?: 'bar . should == false
-    s responds_to?: 'bar: . should == true
+    s responds_to?: 'foo . is: false
+    s responds_to?: 'foo: . is: true
+    s responds_to?: 'bar . is: false
+    s responds_to?: 'bar: . is: true
   }
 
-  it: "should define getter & setter methods for single slots" for: 'read_write_slot: when: {
+  it: "defines getter & setter methods for single slots" with: 'read_write_slot: when: {
     class GettersAndSetters {
       read_write_slot: 'foo
       read_write_slot: 'bar
     }
 
     gs = GettersAndSetters new
-    gs responds_to?: 'foo . should == true
-    gs responds_to?: 'foo: . should == true
-    gs responds_to?: 'bar . should == true
-    gs responds_to?: 'bar: . should == true
+    gs responds_to?: 'foo . is: true
+    gs responds_to?: 'foo: . is: true
+    gs responds_to?: 'bar . is: true
+    gs responds_to?: 'bar: . is: true
   }
 
-  it: "should find the instance variable correctly" when: {
+  it: "finds the instance variable correctly" when: {
     class AClass {
       def initialize: foo {
         @foo = foo
@@ -128,11 +130,11 @@ FancySpec describe: Class with: {
 
     str = "instance value"
     instance = AClass new: str
-    instance foo should == str
-    AClass new foo should == nil
+    instance foo is: str
+    AClass new foo is: nil
   }
 
-  it: "should find the class variable correctly" when: {
+  it: "finds the class variable correctly" when: {
     class AClass {
       def foo: foo {
         @@foo = foo
@@ -146,17 +148,17 @@ FancySpec describe: Class with: {
     instance2 = AClass new
     str = "class value"
     instance1 foo: str
-    instance1 foo should == str
-    instance2 foo should == str
-    instance2 foo should == (instance1 foo)
+    instance1 foo is: str
+    instance2 foo is: str
+    instance2 foo is: (instance1 foo)
 
     str2 = "another value"
     instance2 foo: str2
-    instance2 foo should == str2
-    instance1 foo should == str2
+    instance2 foo is: str2
+    instance1 foo is: str2
   }
 
-  it: "should have correct method overloading for method names with and without an argument" when: {
+  it: "has correct method overloading for method names with and without an argument" when: {
     class AClass {
       def foo {
         foo: "None!"
@@ -168,11 +170,11 @@ FancySpec describe: Class with: {
     }
 
     instance = AClass new
-    instance foo should == "In AClass#foo: with bar = None!"
-    instance foo: "Test!" . should == "In AClass#foo: with bar = Test!"
+    instance foo is: "In AClass#foo: with bar = None!"
+    instance foo: "Test!" . is: "In AClass#foo: with bar = Test!"
   }
 
-  it: "should call superclass method by using super" when: {
+  it: "calls a superclass method by using super" when: {
     class SuperClass {
       read_slots: ['name]
       def initialize: name {
@@ -193,76 +195,76 @@ FancySpec describe: Class with: {
     }
 
     sub = SubClass new: 42
-    sub name should == "SubClass"
-    sub age should == 42
+    sub name is: "SubClass"
+    sub age is: 42
 
     sub2 = SubClass new
-    sub2 name should == "SubClass"
-    sub2 age should == 0
+    sub2 name is: "SubClass"
+    sub2 age is: 0
   }
 
-  it: "should return its superclass" when: {
-    Fixnum superclass should == Integer
-    Symbol superclass should == Object
-    StdError superclass should == Exception
-    Class superclass should == Module
-    Object superclass should == nil
+  it: "returns its superclass" when: {
+    Fixnum superclass is: Integer
+    Symbol superclass is: Object
+    StdError superclass is: Exception
+    Class superclass is: Module
+    Object superclass is: nil
 
-    IOError superclass should == StandardError
-    NoMethodError superclass should == NameError
+    IOError superclass is: StandardError
+    NoMethodError superclass is: NameError
   }
 
-  it: "should create a new Class dynamically" when: {
+  it: "creates 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
+    x is_a?: Class . is: true
+    x new is_a?: x . is: true
+    x new is_a?: Object . is: true
+    x new class is: 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
+    y is_a?: Class . is: true
+    y new is_a?: String . is: true
+    y new is_a?: Object . is: true
   }
 
-  it: "should only be able to call the public method from outside the Class" when: {
+  it: "only is able to call the public method from outside the Class" when: {
     x = ClassWithPrivate new
-    x public_method should == "public!"
+    x public_method is: "public!"
     try {
-      x private_method should == nil # should fail
+      x private_method is: nil # is fail
     } catch NoMethodError => e {
-      e method_name should == 'private_method
+      e method_name is: 'private_method
     }
     try {
-      x protected_method should == nil # should fail
+      x protected_method is: nil # is fail
     } catch NoMethodError => e {
-      e method_name should == 'protected_method
+      e method_name is: 'protected_method
     }
   }
 
-  it: "should be a subclass of another Class" for: 'subclass?: when: {
+  it: "is a subclass of another Class" with: 'subclass?: when: {
     class Super {
     }
     class Sub : Super {
     }
 
-    Super subclass?: Object . should == true
-    Sub subclass?: Object . should == true
-    Sub subclass?: Super . should == true
-    Super subclass?: Sub . should == nil
+    Super subclass?: Object . is: true
+    Sub subclass?: Object . is: true
+    Sub subclass?: Super . is: true
+    Super subclass?: Sub . is: nil
   }
 
-  it: "should dynamically create a subclass of another class" for: 'is_a?: when: {
+  it: "dynamically creates a subclass of another class" with: '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!"
+    subclass is_a?: Class . is: true
+    subclass subclass?: String . is: true
+    subclass new is_a?: subclass . is: true
+    subclass new foo is: "hello, world!"
 
     # now the same with Class##new:body:
     subclass2 = Class superclass: String body: {
@@ -270,53 +272,53 @@ FancySpec describe: Class with: {
         "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!"
+    subclass2 is_a?: Class . is: true
+    subclass2 subclass?: String . is: true
+    subclass2 new is_a?: subclass2 . is: true
+    subclass2 new foo is: "hello, world, again!"
   }
 
-  it: "should undefine an instance method" for: 'undefine_method: when: {
+  it: "undefines an instance method" with: 'undefine_method: when: {
     class Foo {
       def instance_method {
         "instance method!"
       }
     }
     f = Foo new
-    f instance_method should == "instance method!"
+    f instance_method is: "instance method!"
     Foo undefine_method: 'instance_method
     try {
-      f instance_method should == nil # should not get here
+      f instance_method is: nil # is not get here
     } catch NoMethodError => e {
-      e method_name should == 'instance_method
+      e method_name is: 'instance_method
     }
   }
 
-  it: "should undefine a class method" for: 'undefine_class_method: when: {
+  it: "undefines a class method" with: 'undefine_class_method: when: {
     class Foo {
       def self class_method {
         "class method!"
       }
     }
-    Foo class_method should == "class method!"
+    Foo class_method is: "class method!"
 
     try {
       Foo undefine_method: 'class_method
-      true should == nil # should not happen
+      true is: nil # is not happen
     } catch NameError {
-      true should == true
+      true is: true
     }
 
     Foo undefine_class_method: 'class_method
 
     try {
-      Foo class_method should == nil # should not get here
+      Foo class_method is: nil # is not get here
     } catch NoMethodError => e {
-      e method_name should == 'class_method
+      e method_name is: 'class_method
     }
   }
 
-  it: "should have nested classes" when: {
+  it: "has nested classes" when: {
     class Outer {
       class Inner {
         class InnerMost {
@@ -326,11 +328,11 @@ FancySpec describe: Class with: {
         }
       }
     }
-    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!"
+    Outer is_a?: Class . is: true
+    Outer Inner is_a?: Class . is: true
+    Outer Inner InnerMost is_a?: Class . is: true
+    obj = Outer Inner InnerMost new
+    obj foobar is: "foobar!"
 
     # change InnerMost#foobar
     class Outer::Inner::InnerMost {
@@ -338,10 +340,10 @@ FancySpec describe: Class with: {
         "oh no!"
       }
     }
-    obj foobar . should == "oh no!"
+    obj foobar is: "oh no!"
   }
 
-  it: "should not override existing classes with the same name in a nested class" when: {
+  it: "does not override existing classes with the same name in a nested class" when: {
     StdArray = Array
     class NameSpace {
       class Array {
@@ -351,29 +353,29 @@ FancySpec describe: Class with: {
       }
     }
 
-    NameSpace::Array what_am_i . should == "not the same as the standard Array class"
-    NameSpace::Array should_not == Array
+    NameSpace Array what_am_i is: "not the same as the standard Array class"
+    NameSpace Array is_not: Array
   }
 
-  # it: "should return all nested classes of a class" for: 'nested_classes when: {
+  # it: "returns all nested classes of a class" with: 'nested_classes when: {
   #   class Outer {
   #   }
-  #   Outer nested_classes should == []
+  #   Outer nested_classes is: []
 
   #   class Outer {
   #     class Inner1 {
   #     }
   #   }
-  #   Outer nested_classes should == [Outer::Inner1]
+  #   Outer nested_classes is: [Outer::Inner1]
 
   #   class Outer {
   #     class Inner2 {
   #     }
   #   }
-  #   Outer nested_classes should == [Outer::Inner1, Outer::Inner2]
+  #   Outer nested_classes is: [Outer Inner1, Outer Inner2]
   # }
 
-  it: "should find other nested classes in the same parent class" when: {
+  it: "finds other nested classes in the same parent class" when: {
     class MyOuter {
       class Inner1 {
         def method1 {
@@ -388,12 +390,12 @@ FancySpec describe: Class with: {
       }
     }
 
-    MyOuter::Inner1 new method1 should == 'method_1
-    MyOuter::Inner2 new method1 should == 'method_1
-    MyOuter::Inner2 new method2 should == 'method_2
+    MyOuter Inner1 new method1 is: 'method_1
+    MyOuter Inner2 new method1 is: 'method_1
+    MyOuter Inner2 new method2 is: 'method_2
   }
 
-  it: "should find itself in it's own methods, even if nested into another class" when: {
+  it: "finds itself in it's own methods, even if nested into another class" when: {
     class MyOuter {
       class MyInner1 {
         def method1 {
@@ -413,13 +415,13 @@ FancySpec describe: Class with: {
       }
     }
 
-    MyOuter::MyInner1 new method1 should == MyOuter::MyInner1
-    MyOuter::MyInner2 new method2 should == [MyOuter::MyInner1, MyOuter::MyInner2]
-    MyOuter::MyInner1 class_method1 should == MyOuter::MyInner1
-    MyOuter::MyInner2 class_method2 should == [MyOuter::MyInner1, MyOuter::MyInner2]
+    MyOuter MyInner1 new method1 is: MyOuter MyInner1
+    MyOuter MyInner2 new method2 is: [MyOuter MyInner1, MyOuter MyInner2]
+    MyOuter MyInner1 class_method1 is: MyOuter MyInner1
+    MyOuter MyInner2 class_method2 is: [MyOuter MyInner1, MyOuter MyInner2]
   }
 
-  it: "should have an alias method as defined" for: 'alias_method:for: when: {
+  it: "has an alias method as defined" with: 'alias_method:for: when: {
     class AClass {
       def foo {
         "in foo!"
@@ -429,25 +431,25 @@ FancySpec describe: Class with: {
     }
 
     obj = AClass new
-    obj foo should == "in foo!"
-    obj bar should == "in foo!"
+    obj foo is: "in foo!"
+    obj bar is: "in foo!"
   }
 
-  it: "should have an alias method for a ruby method defined" for: 'alias_method:for_ruby: when: {
+  it: "has an alias method for a ruby method defined" with: 'alias_method:for_ruby: when: {
     try {
-      [] equal?: [1,2] . should == true # should fail
+      [] equal?: [1,2] . is: true # is fail
     } catch NoMethodError => e {
-      e method_name should == 'equal?:
+      e method_name is: 'equal?:
     }
 
     class Array {
       alias_method: 'equal?: for_ruby: 'equal?
     }
 
-    [] equal?: [1,2] . should == false
+    [] equal?: [1,2] . is: false
   }
 
-  it: "should have the correct list of ancestors" for: 'ancestors when: {
+  it: "has the correct list of ancestors" with: 'ancestors when: {
     class A {
     }
     class B : A {
@@ -455,8 +457,95 @@ FancySpec describe: Class with: {
     class C : B {
     }
 
-    A ancestors should == [A, Object, Kernel]
-    B ancestors should == [B, A, Object, Kernel]
-    C ancestors should == [C, B, A, Object, Kernel]
+    A ancestors is: [A, Object, Kernel]
+    B ancestors is: [B, A, Object, Kernel]
+    C ancestors is: [C, B, A, Object, Kernel]
+  }
+
+  it: "makes methods private" with: 'private: when: {
+    class AClassWithPrivateMethods {
+      def a {
+        "in a"
+      }
+      def b {
+        "in b"
+      }
+      private: ['a, 'b]
+    }
+
+    x = AClassWithPrivateMethods new
+    { x a } raises: NoMethodError
+    { x b } raises: NoMethodError
+    AClassWithPrivateMethods instance_method: 'a . private? is: true
+    AClassWithPrivateMethods instance_method: 'b . private? is: true
+  }
+
+  it: "makes methods protected" with: 'protected: when: {
+    class AClassWithProtectedMethods {
+      def a {
+        "in a"
+      }
+      def b {
+        "in b"
+      }
+      protected: ['a, 'b]
+    }
+
+    x = AClassWithProtectedMethods new
+    { x a } raises: NoMethodError
+    { x b } raises: NoMethodError
+    AClassWithProtectedMethods instance_method: 'a . private? is: false
+    AClassWithProtectedMethods instance_method: 'b . private? is: false
+    AClassWithProtectedMethods instance_method: 'a . protected? is: true
+    AClassWithProtectedMethods instance_method: 'b . protected? is: true
+  }
+
+  it: "makes methods public" with: 'public: when: {
+    class AClassWithPublicMethods {
+      def a {
+        "in a"
+      }
+      def b {
+        "in b"
+      }
+      private: ['a, 'b]
+      public: ['a, 'b] # making sure Class#public: works.
+    }
+
+    x = AClassWithPublicMethods new
+    { x a } does_not raise: NoMethodError
+    { x b } does_not raise: NoMethodError
+    AClassWithPublicMethods instance_method: 'a . private? is: false
+    AClassWithPublicMethods instance_method: 'b . private? is: false
+    AClassWithPublicMethods instance_method: 'a . protected? is: false
+    AClassWithPublicMethods instance_method: 'b . protected? is: false
+    AClassWithPublicMethods instance_method: 'a . public? is: true
+    AClassWithPublicMethods instance_method: 'b . public? is: true
+  }
+
+  it: "defines a class without a body" when: {
+    class Foo
+    Foo is_a?: Class . is: true
+    Foo new is_a?: Foo . is: true
+
+    class FooNew : Foo
+    FooNew is_a?: Class . is: true
+    FooNew ancestors includes?: Foo . is: true
+    FooNew new is_a?: Foo . is: true
+  }
+
+  it: "defines a class with empty methods" when: {
+    class Foo
+    class Bar : Foo {
+      def initialize: @bar
+      def empty_method
+      def to_s {
+        @bar + "bar"
+      }
+    }
+
+    b = Bar new: "foo"
+    b to_s is: "foobar"
+    b empty_method is: nil
   }
 }