fancy 0.3.3 → 0.4.0

data/lib/false_class.fy

@@ -1,5 +1,7 @@
 class FalseClass {
-  "FalseClass. The class of the singleton @false value."
+  """
+  FalseClass. The class of the singleton @false value.
+  """
 
   def FalseClass new {
     # always return false singleton object when trying to create a new
@@ -35,6 +37,8 @@ class FalseClass {
     "false"
   }
 
+  alias_method: 'inspect for: 'to_s
+
   def to_a {
     "Returns an empty @Array@."
     []
@@ -50,3 +54,8 @@ class FalseClass {
     true
   }
 }
+
+false documentation: """
+  @false is the singleton boolean false value (only instance of @FalseClass@).
+  FalseClass##new yields @false.
+  """

data/lib/fancy_spec.fy

@@ -4,29 +4,77 @@ class FancySpec {
   Have a look at the tests/ directory to see some examples.
   """
 
-
   def initialize: @description test_obj: @test_obj (@description) {
+    """
+    @description Description @String@ for testcase.
+    @test_obj Object to be tested, defaults to @description.
+    """
+
     @spec_tests = []
+    @before_blocks = []
+    @after_blocks = []
   }
 
   def FancySpec describe: test_obj with: block {
+    """
+    Factory method for creating FancySpec instances.
+    Calls @block with the new FancySpec instance as the receiver, then runs it.
+
+        FancySpec describe: MyTestClass with: {
+          # test cases using it:for:when: here.
+        }
+    """
+
     spec = FancySpec new: test_obj
     block call_with_receiver: spec
     spec run
   }
 
   def FancySpec describe: description for: test_obj with: block {
+    """
+    Similar to FancySpec##describe:with: but also taking an explicit @test_obj.
+
+        FancySpec describe: \"My cool class\" for: MyCoolClass with: {
+          # test cases using it:for:when: here.
+        }
+    """
+
     spec = FancySpec new: description test_obj: test_obj
     block call_with_receiver: spec
     spec run
   }
 
   def it: spec_info_string when: spec_block {
+    """
+    @spec_info_string Info @String@ related to the test case defined in @spec_block.
+    @spec_block @Block@ that holds the testcase's code (including assertions).
+
+    Example usage:
+        it: \"should be an empty Array\" when: {
+          arr = [1,2,3]
+          3 times: { arr pop }
+          arr empty? is == true
+        }
+    """
+
     test = SpecTest new: spec_info_string block: spec_block
     @spec_tests << test
   }
 
-  def it: spec_info_string for: method_name when: spec_block {
+  def it: spec_info_string with: method_name when: spec_block {
+    """
+    @spec_info_string Info @String@ related to the test case defined in @spec_block.
+    @method_name Name of Method that this testcase is related to.
+    @spec_block @Block@ that holds the testcase's code (including assertions).
+
+    Example usage:
+        it: \"should be an empty Array\" with: 'empty? when: {
+          arr = [1,2,3]
+          3 times: { arr pop }
+          arr empty? is == true
+        }
+    """
+
     test = SpecTest new: spec_info_string block: spec_block
     # try {
     #   @test_obj method: method_name . if_true: |method| {
@@ -38,12 +86,40 @@ class FancySpec {
     @spec_tests << test
   }
 
+  alias_method: 'it:for:when: for: 'it:with:when:
+
+  def before_each: block {
+    """
+    @block @Block@ to be run before each test case.
+    """
+
+    @before_blocks << block
+  }
+
+  def after_each: block {
+    """
+    @block @Block@ to be run after each test case.
+    """
+
+    @after_blocks << block
+  }
+
   def run {
-    "Running tests for: " ++ @description ++ ": " print
+    """
+    Runs a FancySpec's test cases.
+    """
+
+    # "  " ++ @description ++ ": " print
     @spec_tests each: |test| {
+      @before_blocks each: |b| {
+        b call_with_receiver: test
+      }
       test run: @test_obj
+      @after_blocks each: |b| {
+        b call_with_receiver: test
+      }
     }
-#    Console newline Console newline
+
     # untested_methods = @test_obj methods select: |m| {
     #   m tests size == 0
     # }
@@ -51,63 +127,129 @@ class FancySpec {
       # ["WARNING: These methods need tests:",
       #  untested_methods map: 'name . select: |m| { m whitespace? not } . join: ", "] println
     # }
-    Console newline
   }
 
 
   class SpecTest {
-    @@failed_positive = []
-    @@failed_negative = []
+    """
+    FancySpec test case class.
+    """
+
+    read_slot: 'info_str
+
+    @@failed_positive = <[]>
+    @@failed_negative = <[]>
+    @@failed_count = 0
+    @@total_tests = 0
+    @@total_expectations = 0
+
+    def SpecTest add_expectation {
+      @@total_expectations = @@total_expectations + 1
+    }
 
-    def SpecTest failed_test: actual_and_expected {
-      @@failed_positive << [actual_and_expected, caller(6) at: 0]
+    def SpecTest failed_test: test {
+      """
+      @actual_and_expected Pair of actual and expected values for a failed test case.
+
+      Gets called when a SpecTest failed.
+      """
+
+      @@failed_positive[@@current_test_obj]: $ @@failed_positive[@@current_test_obj] || { Set new }
+      @@failed_positive[@@current_test_obj] << test
+      @@failed_count = @@failed_count + 1
+    }
+
+    def SpecTest failed_negative_test: test {
+      """
+      @value Value that should not have occured.
+
+      Gets called when a negative SpecTest (using @NegativeMatcher@) failed.
+      """
+
+      @@failed_negative[@@current_test_obj]: $ @@failed_negative[@@current_test_obj] || { Set new }
+      @@failed_negative[@@current_test_obj] << test
+      @@failed_count = @@failed_count + 1
     }
 
-    def SpecTest failed_negative_test: value {
-      @@failed_negative << [value, caller(6) at: 0]
+    def SpecTest current {
+      @@current
+    }
+
+    def SpecTest print_failures {
+      @@failed_positive each: |test_obj failed_tests| {
+        failed_tests each: |t| {
+          Console newline
+          "> FAILED: " ++ test_obj ++ " " ++ (t info_str) print
+          t print_failed_positive
+        }
+      }
+
+      @@failed_negative each: |test_obj failed_tests| {
+        failed_tests each: |t| {
+          Console newline
+          "> FAILED: " ++ test_obj ++ " " ++ (t info_str) print
+          t print_failed_negative
+        }
+      }
+
+      Console newline
+      "Ran #{@@total_tests} tests (#{@@total_expectations} expectations) with #{@@failed_count} failures." println
+      if: (@@failed_count > 0) then: {
+        System exit: 1
+      } else: {
+        System exit: 0
+      }
     }
 
     def initialize: @info_str block: @block {
-      { @@failed_positive = [] } unless: @@failed_positive
-      { @@failed_negative = [] } unless: @@failed_negative
+      { @@failed_positive = <[]> } unless: @@failed_positive
+      { @@failed_negative = <[]> } unless: @@failed_negative
+      @failed_positive = []
+      @failed_negative = []
     }
 
     def run: test_obj {
-      @@failed_positive = []
-      @@failed_negative = []
+      @@current_test_obj = test_obj
+      @@current = self
+      @@total_tests = @@total_tests + 1
       try {
-        @block call
-      } catch IOError => e {
-        SpecTest failed_test: [e, "UNKNOWN"]
+        @block call_with_receiver: self
+      } catch Exception => e {
+        failed: (e, "No Exception")
       }
 
-      any_failure = nil
-      if: (@@failed_positive size > 0) then: {
-        any_failure = true
-        Console newline
-        "> FAILED: " ++ test_obj ++ " " ++ @info_str print
-        print_failed_positive
+      if: failed? then: {
+        "f" print
+      } else: {
+        "." print
       }
+    }
 
-      if: (@@failed_negative size > 0) then: {
-        any_failure = true
-        Console newline
-        "> FAILED: " ++ test_obj ++ " " ++ @info_str print
-        print_failed_negative
-      }
+    def failed: actual_and_expected {
+      @failed_positive << (actual_and_expected, caller(5) at: 0)
+      SpecTest failed_test: self
+    }
+
+    def failed_negative: value {
+      { value = [value, 'negative_failure] } unless: $ value responds_to?: 'at:
+      @failed_negative << (value, caller(6) at: 0)
+      SpecTest failed_negative_test: self
+    }
 
-      { "." print } unless: any_failure
+    def failed? {
+      @failed_positive empty? not || { @failed_negative empty? not }
     }
 
+
     def print_failed_positive {
-      " [" ++ (@@failed_positive size) ++ " unexpected values]" println
-      print_failed_common: @@failed_positive
+      " [" ++ (@failed_positive size) ++ " unexpected values]" println
+      print_failed_common: @failed_positive
     }
 
     def print_failed_negative {
-      " [" ++ (@@failed_negative size) ++ " unexpected values]" println
+      " [" ++ (@failed_negative size) ++ " unexpected values]" println
       "Should not have gotten the following values: " println
-      print_failed_common: @@failed_negative
+      print_failed_common: @failed_negative
     }
 
     def print_failed_common: failures {
@@ -117,75 +259,103 @@ class FancySpec {
         location = location split: "/" . from: -2 to: -1 . join: "/"
 
         location println
-        "    Expected: #{expected inspect}" println
-        "    Received: #{actual inspect}" println
+        unless: (expected == 'negative_failure) do: {
+          "    Expected: #{expected inspect}" println
+          "    Received: #{actual inspect}" println
+        } else: {
+          "    " ++ (actual inspect) println
+        }
       }
     }
   }
 
   class PositiveMatcher {
-    """PositiveMatcher expects its actual value to be equal to an
-       expected value.
-       If the values are not equal, a SpecTest failure is generated."""
+    """
+    PositiveMatcher expects its actual value to be equal to an
+    expected value.
+    If the values are not equal, a SpecTest failure is generated.
+    """
 
     def initialize: @actual_value {
+      SpecTest add_expectation
     }
 
     def == expected_value {
       unless: (@actual_value == expected_value) do: {
-        SpecTest failed_test: [@actual_value, expected_value]
+        SpecTest current failed: (@actual_value, expected_value)
       }
     }
 
     def != expected_value {
       unless: (@actual_value != expected_value) do: {
-        SpecTest failed_negative_test: [@actual_value, expected_value]
+        SpecTest current failed_negative: (@actual_value, expected_value)
       }
     }
 
     def raise: exception_class {
       try {
         @actual_value call
+        # make sure we raise an exception.
+        # if no exepction raised at this point, we have an error.
+        SpecTest current failed: (nil, exception_class)
       } catch exception_class {
         # ok
       } catch Exception => e {
-        SpecTest failed_test: [e class, exception_class]
+        SpecTest current failed: (e class, exception_class)
+      }
+    }
+
+    def raise: exception_class with: block {
+      try {
+        @actual_value call
+        # same here
+        SpecTest current failed: (nil, exception_class)
+      } catch exception_class => e {
+        block call: [e]
+        # ok
+      } catch Exception => e {
+        SpecTest current failed: (e class, exception_class)
       }
     }
 
     def unknown_message: msg with_params: params {
-      """Forwardy any other message and parameters to the object itself
-         and checks the return value."""
+      """
+      Forwards any other message and parameters to the object itself
+      and checks the return value.
+      """
 
-      unless: (@actual_value send_message: msg with_params: params) do: {
-        SpecTest failed_test: [@actual_value, params first]
+      unless: (@actual_value receive_message: msg with_params: params) do: {
+        SpecTest current failed: (@actual_value, params first)
       }
     }
 
     def be: block {
       unless: (block call: [@actual_value]) do: {
-        SpecTest failed_test: [@actual_value, nil]
+        SpecTest current failed: (@actual_value, nil)
       }
     }
   }
 
   class NegativeMatcher {
-    """NegativeMatcher expects its actual value to be unequal to an
-       expected value.
-       If the values are equal, a SpecTest failure is generated."""
+    """
+    NegativeMatcher expects its actual value to be unequal to an
+    expected value.
+    If the values are equal, a SpecTest failure is generated.
+    """
 
     def initialize: @actual_value {
+      SpecTest add_expectation
     }
 
     def == expected_value {
       if: (@actual_value == expected_value) then: {
-        SpecTest failed_negative_test: @actual_value
+        SpecTest current failed_negative: @actual_value
       }
     }
 
     def != expected_value {
       if: (@actual_value != expected_value) then: {
-        SpecTest failed_test: [@actual_value, expected_value]
+        SpecTest current failed: (@actual_value, expected_value)
       }
     }
 
@@ -193,7 +363,7 @@ class FancySpec {
       try {
         @actual_value call
       } catch exception_class {
-        SpecTest failed_negative_test: [exception_class, nil]
+        SpecTest current failed_negative: (exception_class, nil)
       } catch Exception => e {
         true
         # ok
@@ -201,17 +371,19 @@ class FancySpec {
     }
 
     def unknown_message: msg with_params: params {
-      """Forwardy any other message and parameters to the object itself
-         and checks the return value."""
+      """
+      Forwards any other message and parameters to the object itself
+      and checks the return value.
+      """
 
-      if: (@actual_value send_message: msg with_params: params) then: {
-        SpecTest failed_negative_test: @actual_value
+      if: (@actual_value receive_message: msg with_params: params) then: {
+        SpecTest current failed_negative: @actual_value
       }
     }
 
     def be: block {
       if: (block call: [@actual_value]) then: {
-        SpecTest failed_negative_test: @actual_value
+        SpecTest current failed_negative: @actual_value
       }
     }
   }
@@ -219,12 +391,42 @@ class FancySpec {
 
 class Object {
   def should {
-    "Returns a PositiveMatcher for self."
+    """
+    Returns a @PositiveMatcher@ for self.
+    """
+
     FancySpec PositiveMatcher new: self
   }
 
+  alias_method: 'is for: 'should
+  alias_method: 'does for: 'should
+
+  def is: expected {
+    is == expected
+  }
+
+  def is_not: expected {
+    does_not == expected
+  }
+
   def should_not {
-    "Returns a NegativeMatcher for self."
+    """
+    Returns a @NegativeMatcher@ for self.
+    """
+
     FancySpec NegativeMatcher new: self
   }
+
+  alias_method: 'is_not for: 'should_not
+  alias_method: 'does_not for: 'should_not
 }
+
+class Block {
+  def raises: exception_class {
+    FancySpec PositiveMatcher new: self . raise: exception_class
+  }
+
+  def raises: exception_class with: block {
+    FancySpec PositiveMatcher new: self . raise: exception_class with: block
+  }
+}