fancy 0.3.2 → 0.3.3

data/lib/block.fy

@@ -34,6 +34,16 @@ class Block {
     while_false: block
   }
 
+  def while_true: work {
+    {
+      call if_true: |val| {
+        work call: [val]
+      } else: {
+        break
+      }
+    } loop
+  }
+
   alias_method: 'while_do: for: 'while_true:
 
   def until_do: block {
@@ -85,6 +95,13 @@ class Block {
   }
 
   def === val {
+    """
+    @val Other object to match @self against.
+    @return Value of calling @self with @val.
+
+    Matches a @Block against another object by calling @self with @val.
+    """
+
     call: [val]
   }
-}
+}

data/lib/boot.fy

@@ -17,12 +17,15 @@ require: "object"
 require: "class"
 require: "true_class"
 require: "nil_class"
+require: "false_class"
 require: "number"
 require: "enumerable"
 require: "string"
 require: "array"
 require: "tuple"
 require: "block"
+require: "iteration"
+require: "enumerator"
 require: "file"
 require: "directory"
 require: "fancy_spec"
@@ -36,6 +39,7 @@ require: "thread_pool"
 require: "fiber"
 require: "fiber_pool"
 require: "future"
+require: "struct"
 
 # version holds fancy's version number
 require: "version"
@@ -43,4 +47,4 @@ require: "argv"
 
 require: "documentation"
 
-require: "package.fy"
+require: "package.fy"

data/lib/compiler/ast/class_def.fy

@@ -18,7 +18,7 @@ class Fancy AST {
     def bytecode: g {
       pos(g)
       docstring = body() body() shift_docstring
-      docstring if_do: {
+      docstring if_true: {
         setdoc = MessageSend new: @line \
                              message: (Identifier from: "for:append:" line: @line) \
                              to: (Identifier from: "Fancy::Documentation" line: @line) \

data/lib/compiler/ast/identifier.fy

@@ -25,10 +25,10 @@ class Fancy AST {
     }
 
     def method_name: receiver ruby_send: ruby (false) {
-      ruby || @ruby_ident if_do: {
+      ruby || @ruby_ident if_true: {
         @string to_sym()
       } else: {
-        @string =~ /:$/ . if_do: {
+        @string =~ /:$/ . if_true: {
           @string to_sym()
         } else: {
           ":" + @string . to_sym()

data/lib/compiler/ast/message_send.fy

@@ -76,7 +76,7 @@ class Fancy AST {
         if: (@args last kind_of?: Identifier) then: {
           if: (@args last string =~ /^&\w/) then: {
             @block = @args pop()
-            @block = Identifier new: (@block line) string: (@block string from: 1 to: -1)
+            @block = Identifier from: (@block string from: 1 to: -1) line: (@block line)
           }
         }
       }
@@ -84,7 +84,7 @@ class Fancy AST {
       if: (@args last kind_of?: Identifier) then: {
         if: (@args last string =~ /^\*\w/) then: {
           @splat = @args pop()
-          @splat = Identifier new: (@splat line) string: (@splat string from: 1 to: -1)
+          @splat = Identifier from: (@splat string from: 1 to: -1) line: (@splat line)
         }
       }
     }

data/lib/compiler/ast/method_def.fy

@@ -27,10 +27,10 @@ class Fancy AST {
       g send(@access, 0)
       g pop()
 
-      @name to_s =~ /^initialize:(\S)+/ if_do: {
+      @name to_s =~ /^initialize:(\S)+/ if_true: {
         define_constructor_class_method: g
       }
-      @name to_s =~ /^unknown_message:with_params:$/ if_do: {
+      @name to_s =~ /^unknown_message:with_params:$/ if_true: {
         define_method_missing: g
       }
 

data/lib/compiler/ast/try_catch.fy

@@ -1,7 +1,11 @@
 class Fancy AST {
   class TryCatch : Node {
 
-    def initialize: @line body: @body handlers: @handlers ensure: @ensure {}
+    def initialize: @line body: @body handlers: @handlers ensure: @ensure {
+      if: (@body empty?) then: {
+        @body unshift_expression: $ NilLiteral new: @line
+      }
+    }
 
     def bytecode: g {
       pos(g)

data/lib/documentation.fy

@@ -63,7 +63,7 @@ class Fancy Documentation {
       If obj has no documentation, one is created for it.
     """
     doc = for: obj
-    doc if_do: {
+    if: doc then: {
       doc docs << docstring
     } else: {
       doc  = for: obj is: docstring

data/lib/enumerable.fy

@@ -19,14 +19,10 @@ class FancyEnumerable {
     calling the first @Block@ for each element in self.
     """
 
-    count = 0
-    size = self size
+    between = { between = between_block }
     each: |x| {
+      between call
       each_block call: [x]
-      unless: (count == (size - 1)) do: {
-        between_block call
-      }
-      count = count + 1
     }
   }
 
@@ -81,7 +77,7 @@ class FancyEnumerable {
     """
 
     each: |x| {
-      block call: [x] . if_do: |item| {
+      if: (block call: [x]) then: |item| {
         return item
       }
     }

data/lib/enumerator.fy

@@ -0,0 +1,77 @@
+class FancyEnumerator {
+  def initialize: @object {
+    @iterator = 'each:
+    rewind
+  }
+
+  def initialize: @object with: @iterator {
+    rewind
+  }
+
+  def next {
+    if: @peeked then: {
+      @peeked = false
+      @peek
+    } else: {
+      result = @fiber resume
+      if: (@fiber alive?) then: {
+        return result
+      } else: {
+        (Fancy StopIteration new: result) raise!
+      }
+    }
+  }
+
+  def peek {
+    """
+    Returns the next object in the FancyEnumerator, but doesn't move the
+    internal position forward.
+    When the position reaches the end, a Fancy StopIteration exception is
+    raised.
+
+    a = [1,2,3]
+    e = a to_enum
+    e next p #=> 1
+    e peek p #=> 2
+    e peek p #=> 2
+    e peek p #=> 2
+    e next p #=> 2
+    e next p #=> 3
+    e next p #=> raises Fancy StopIteration
+    """
+
+    unless: @peeked do: {
+      @peeked = true
+      @peek = @fiber resume
+      if: (@fiber alive?) then: {
+        return @peek
+      } else: {
+        (Fancy StopIteration new: result) raise!
+      }
+    }
+
+    return @peek
+  }
+
+  def rewind {
+    @peeked = false
+    @peek = nil
+
+    @fiber = Fiber new: {
+      param = |element| { yield: element }
+      @object send_message: @iterator with_params: [param]
+    }
+  }
+
+  def with: object each: block {
+    loop: {
+      try {
+        block call: [next, object]
+      } catch (Fancy StopIteration) => ex {
+        return object
+      }
+    }
+
+    return object
+  }
+}

data/lib/false_class.fy

@@ -0,0 +1,52 @@
+class FalseClass {
+  "FalseClass. The class of the singleton @false value."
+
+  def FalseClass new {
+    # always return false singleton object when trying to create a new
+    # FalseClass instance
+    false
+  }
+
+  def if_true: block {
+    "Returns @nil."
+    nil
+  }
+
+  def if_true: then_block else: else_block {
+    "Calls @else_block."
+    else_block call
+  }
+
+  def if_false: block {
+    block call: [self]
+  }
+
+  def if_false: then_block else: else_block {
+    then_block call: [self]
+  }
+
+  def false? {
+    "Returns @true."
+    true
+  }
+
+  def to_s {
+    "Returns @false as a @String@."
+    "false"
+  }
+
+  def to_a {
+    "Returns an empty @Array@."
+    []
+  }
+
+  def not {
+    """
+    @return @true
+
+    Boolean negation of @false => @true.
+    """
+
+    true
+  }
+}

data/lib/fancy_spec.fy

@@ -29,7 +29,7 @@ class FancySpec {
   def it: spec_info_string for: method_name when: spec_block {
     test = SpecTest new: spec_info_string block: spec_block
     # try {
-    #   @test_obj method: method_name . if_do: |method| {
+    #   @test_obj method: method_name . if_true: |method| {
     #     method tests << test
     #   }
     # } catch MethodNotFoundError => e {
@@ -60,11 +60,11 @@ class FancySpec {
     @@failed_negative = []
 
     def SpecTest failed_test: actual_and_expected {
-      @@failed_positive << actual_and_expected
+      @@failed_positive << [actual_and_expected, caller(6) at: 0]
     }
 
     def SpecTest failed_negative_test: value {
-      @@failed_negative << value
+      @@failed_negative << [value, caller(6) at: 0]
     }
 
     def initialize: @info_str block: @block {
@@ -101,17 +101,24 @@ class FancySpec {
 
     def print_failed_positive {
       " [" ++ (@@failed_positive size) ++ " unexpected values]" println
-      "Got: " println
-      @@failed_positive each: |f| {
-        "     " ++ (f first inspect) ++ " instead of: " ++ (f second inspect) println
-      }
+      print_failed_common: @@failed_positive
     }
 
     def print_failed_negative {
       " [" ++ (@@failed_negative size) ++ " unexpected values]" println
       "Should not have gotten the following values: " println
-      @@failed_negative each: |f| {
-        "     " ++ (f inspect) println
+      print_failed_common: @@failed_negative
+    }
+
+    def print_failed_common: failures {
+      failures each: |f| {
+        actual, expected = f first
+        location = f second gsub(/:(\d+):in `[^']+'/, " +\1")
+        location = location split: "/" . from: -2 to: -1 . join: "/"
+
+        location println
+        "    Expected: #{expected inspect}" println
+        "    Received: #{actual inspect}" println
       }
     }
   }
@@ -132,7 +139,17 @@ class FancySpec {
 
     def != expected_value {
       unless: (@actual_value != expected_value) do: {
-        SpecTest failed_negative_test: @actual_value
+        SpecTest failed_negative_test: [@actual_value, expected_value]
+      }
+    }
+
+    def raise: exception_class {
+      try {
+        @actual_value call
+      } catch exception_class {
+        # ok
+      } catch Exception => e {
+        SpecTest failed_test: [e class, exception_class]
       }
     }
 
@@ -140,7 +157,7 @@ class FancySpec {
       """Forwardy any other message and parameters to the object itself
          and checks the return value."""
 
-      unless: (@actual_value send: msg params: params) do: {
+      unless: (@actual_value send_message: msg with_params: params) do: {
         SpecTest failed_test: [@actual_value, params first]
       }
     }
@@ -172,11 +189,22 @@ class FancySpec {
       }
     }
 
+    def raise: exception_class {
+      try {
+        @actual_value call
+      } catch exception_class {
+        SpecTest failed_negative_test: [exception_class, nil]
+      } catch Exception => e {
+        true
+        # ok
+      }
+    }
+
     def unknown_message: msg with_params: params {
       """Forwardy any other message and parameters to the object itself
          and checks the return value."""
 
-      if: (@actual_value send: msg params: params) then: {
+      if: (@actual_value send_message: msg with_params: params) then: {
         SpecTest failed_negative_test: @actual_value
       }
     }

data/lib/fdoc.fy

@@ -284,8 +284,8 @@ class Fancy FDoc {
              method = method sub(/^:/, "")
            }
            sigil = ""
-           name =~ (Regexp.new("^#")) . if_do: { sigil = "<small>#</small>" }
-           type = n[1] include?(":") . if_do: {
+           name =~ (Regexp.new("^#")) . if_true: { sigil = "<small>#</small>" }
+           type = n[1] include?(":") . if_true: {
              if: (sigil == "") then: {
                "singleton-method-ref"
              } else: {

data/lib/file.fy

@@ -27,7 +27,14 @@ class File {
         lines << (f readln)
       }
     }
-    lines join: "\n"
+    lines join
+  }
+
+  def self touch: filename {
+    file = File expand_path(filename)
+    File open: file modes: ['write] with: |f| {
+      f write: ""
+    }
   }
 
   def writeln: x {

data/lib/future.fy

@@ -20,13 +20,34 @@ class Future {
   }
 
   def when_done: block {
-    value if_do: |v| {
-      block call: [v]
+    Future new: {
+      block call: [value]
     }
   }
 
+  def && block {
+    when_done: block
+  }
+
   def value {
     { Thread sleep: WaitInterval } until: { @block complete? }
     @block completed_value
   }
+}
+
+class FutureCollection {
+  include: FancyEnumerable
+
+  def initialize: @futures {
+  }
+
+  def each: block {
+    @futures each: |f| {
+      f when_done: block
+    }
+  }
+
+  def await_all {
+    @futures each: 'value
+  }
 }