fancy 0.3.3 → 0.4.0

data/lib/fdoc.fy

@@ -109,10 +109,11 @@ class Fancy FDoc {
         exec = cls send(type, n) executable()
         methods delete(exec)
         mdoc = Fancy Documentation for: exec
+        { next } unless: mdoc # skip methods with no documentation
         if: mdoc then: {
-          mattr at: 'doc put: $ mdoc format: 'fdoc
+          mattr['doc]: $ mdoc format: 'fdoc
           if: (mdoc meta) then: {
-            mattr at: 'arg put: $ mdoc meta at: 'argnames
+            mattr['arg]: $ mdoc meta at: 'argnames
           }
         }
         if: (exec class() == Rubinius CompiledMethod) then: {
@@ -121,12 +122,12 @@ class Fancy FDoc {
           # TODO: Fix, either use a -r (root) option or use __FILE__
           relative_file = relative_file to_s gsub(/.*lib/, "lib")
           lines = exec lines() to_a()
-          mattr at: 'file put: $ relative_file
+          mattr['file]: $ relative_file
           # TODO calculate line numbers from compiled method
           # right now we only use the first line of code in the body.
-          mattr at: 'lines put: $ [lines[3], lines[3]]
+          mattr['lines]: $ [lines[3], lines[3]]
         }
-        attr[(type ++ "s") intern()] at: n put: mattr
+        attr[(type ++ "s") intern()] [n]: mattr
       }
     }
 
@@ -137,7 +138,7 @@ class Fancy FDoc {
       methods = @methods dup()
 
       @classes each: |cls| {
-        name = cls name() gsub("::", " ")
+        name = cls name gsub("::", " ")
         doc = Fancy Documentation for: cls
         attr = <[
           'doc => doc format: 'fdoc,
@@ -147,7 +148,7 @@ class Fancy FDoc {
         ]>
         popuplate_methods: cls on: attr type: 'instance_method known: methods
         popuplate_methods: cls on: attr type: 'method known: methods
-        map['classes] at: name put: attr
+        map['classes][name]: attr
       }
 
       methods each: |cm| {
@@ -163,7 +164,7 @@ class Fancy FDoc {
           'doc => doc format: 'fdoc
         ]>
 
-        map['methods] at: full_name put: attr
+        map['methods][full_name]: attr
       }
 
       map
@@ -194,7 +195,7 @@ class Fancy FDoc {
     def self format: doc {
       str = doc to_s
       tags = <[ ]>
-      str = remove_indentation: str
+      str = str skip_leading_indentation
       str = remove_tags: str into: tags
       str = create_tags: str with: tags
       str = create_class_references: str
@@ -204,21 +205,6 @@ class Fancy FDoc {
       str
     }
 
-    def self remove_indentation: str {
-      """
-      Remove leading white space for multi-line strings.
-      This method expects the first character to be an line return.
-      """
-      m = /^(\r?\n)*(\s+)/ match(str)
-      str = str strip()
-      if: m then: {
-        pattern = "^ {" ++ (m[2] size()) ++ "}"
-        rex = Regexp.new(pattern)
-        str = str gsub(rex, "");
-      }
-      str
-    }
-
     def self create_class_references: str {
       """
       Creates class references for Fancy class names.
@@ -313,7 +299,7 @@ class Fancy FDoc {
       ary = str split(/\r?\n/) map: |line| {
         m = /^@([a-z@]\S+?)\s+(.*)/ match(line)
         if: m then: {
-          map at: (m[1]) put: (m[2])
+          map[m[1]]: (m[2])
           nil
         } else: {
           line

data/lib/fiber.fy

@@ -1,4 +1,11 @@
 class Fiber {
+  """
+  Fiber class. Fibers are cooperatively scheduled coroutines supported
+  by the Rubinius VM.
+  Control flow between multiple Fibers is always explicitly handled.
+  There is no preemptive scheduler.
+  """
+
   def sleep: seconds {
     @sleep_end = Time now + seconds
   }
@@ -8,4 +15,8 @@ class Fiber {
       Time now < @sleep_end
     }
   }
+
+  def Fiber name {
+    "Fiber"
+  }
 }

data/lib/file.fy

@@ -31,6 +31,12 @@ class File {
   }
 
   def self touch: filename {
+    """
+    @filename Name of @File@ to be created, if not already existant.
+
+    Creates a new empty file with the given @filename, if it doesn't already exist.
+    """
+
     file = File expand_path(filename)
     File open: file modes: ['write] with: |f| {
       f write: ""
@@ -47,15 +53,6 @@ class File {
     newline
   }
 
-  def print: x {
-    "Same as File#write:."
-
-    write: x
-  }
-
-  def println: x {
-    "Same as File#writeln:."
-
-    writeln: x
-  }
+  alias_method: 'print: for: 'write:
+  alias_method: 'println: for: 'writeln:
 }

data/lib/future.fy

@@ -1,16 +1,91 @@
-class Future {
+class FutureSend {
+  read_slots: [ 'fail_reason, 'receiver, 'message, 'params ]
+  def initialize: @actor receiver: @receiver message: @message with_params: @params ([]) {
+    @waiting_threads = []
+    @actor ! ('future, (@message, @params), self)
+  }
+
+  def failed: @fail_reason {
+    synchronized: {
+      @completed = true
+      @failed = true
+      completed!
+    }
+  }
+
+  def completed: @value {
+    synchronized: {
+      @completed = true
+      completed!
+    }
+  }
+
+  def completed! {
+    @waiting_threads each: 'run
+    @waiting_threads = []
+  }
+
+  private: 'completed!
+
+  def completed? {
+    synchronized: {
+      return @completed
+    }
+  }
+
+  def failed? {
+    synchronized: {
+      return @failed
+    }
+  }
+
+  def value {
+    if: completed? then: {
+      return @value
+    } else: {
+      synchronized: {
+        @waiting_threads << (Thread current)
+      }
+      Thread stop
+      return @value
+    }
+  }
+
+  def send_future: message with_params: params {
+    value send_future: message with_params: params
+  }
+
+  def when_done: block {
+    block send_future: 'call: with_params: [value]
+  }
+
+  def && block {
+    when_done: block
+  }
+
+  def inspect {
+    str = "#<FutureSend:0x" ++ (object_id to_s: 16) ++ " @receiver=" ++ @receiver
+    str << " @message="
+    str << (@message inspect)
+    str << " @params="
+    str << (@params inspect)
+    str + ">"
+  }
+}
+
+class PooledFuture {
   @@thread_pool = nil
   @@pool_size = 10
   WaitInterval = 0.1
 
-  def Future pool: n {
+  def PooledFuture pool: n {
     @@pool_size = match n {
       case 0 -> 10
       case _ -> n
     }
   }
 
-  def Future join! {
+  def PooledFuture join! {
     @@thread_pool join
   }
 
@@ -20,7 +95,7 @@ class Future {
   }
 
   def when_done: block {
-    Future new: {
+    PooledFuture new: {
       block call: [value]
     }
   }
@@ -29,8 +104,12 @@ class Future {
     when_done: block
   }
 
+  def completed? {
+    @block complete?
+  }
+
   def value {
-    { Thread sleep: WaitInterval } until: { @block complete? }
+    { Thread sleep: WaitInterval } until: { completed? }
     @block completed_value
   }
 }

data/lib/hash.fy

@@ -6,16 +6,25 @@ class Hash {
 
   include: FancyEnumerable
 
-  def [] key {
-    "Returns the value for a given key."
+  def [key] {
+    """
+    @key Key for value to get.
+    @return Value for given @key or @nil, if @key not set.
+
+    Returns the value for a given key.
+    """
 
     at: key
   }
 
   def each: block {
-    "Calls a given Block with each key and value."
+    """
+    @block @Block@ to be called with each key and value in @self.
+    @return @self
+    Calls a given @Block@ with each key and value.
+    """
 
-    if: (block argcount == 1) then: {
+    if: (block arity == 1) then: {
       keys each: |key| {
         block call: [[key, at: key]]
       }
@@ -24,33 +33,75 @@ class Hash {
         block call: [key, at: key]
       }
     }
+    self
   }
 
   def each_key: block {
-    "Calls a given Block with each key."
+    """
+    @block @Block@ to be called with each key in @self.
+    @return @self
 
-    keys each: |key| {
-      block call: [key]
-    }
+    Calls a given @Block@ with each key.
+    """
+
+    keys each: block
+    self
   }
 
   def each_value: block {
-    "Calls a given Block with each value."
+    """
+    @block @Block@ to be called with each value in @self.
+    @return @self
 
-    values each: |val| {
-      block call: [val]
-    }
+    Calls a given @Block@ with each value.
+    """
+
+    values each: block
+    self
   }
 
   def to_a {
-    "Returns an Array of the key-value pairs in a Hash."
+    """
+    @return @Array@ of all key-value pairs in @self.
+
+    Returns an @Array@ of the key-value pairs in a @Hash@.
+    """
 
     map: |pair| { pair }
   }
 
   def to_s {
-    "Returns a string representation of a Hash."
+    """
+    @return @String@ representation of @self.
+
+    Returns a @String@ representation of a @Hash@.
+    """
 
     to_a to_s
   }
+
+  def inspect {
+    str = "<["
+    each: |key val| {
+      str << (key inspect)
+      str << " => "
+      str << (val inspect)
+    } in_between: {
+      str << ", "
+    }
+    str << "]>"
+    str
+  }
+
+  def values_at: keys {
+    """
+    @keys Collection of keys to get the values for.
+    @return @Array@ of all values for the given keys.
+
+    Example usage:
+      <['foo => 1, 'bar => 2, 'baz => 42]> values_at: ('foo, 'baz) # => [1, 42]
+    """
+
+    keys map: |k| { at: k }
+  }
 }

data/lib/integer.fy

@@ -0,0 +1,35 @@
+class Integer {
+  """
+  Base class for integer values in Fancy.
+  """
+
+  def times: block {
+    """
+    @block @Block@ to be called with each number between 0 and @self.
+    @return @self
+
+    Calls a given @Block@ with each number between 0 and @self.
+    """
+
+    tmp = 0
+    while: { tmp < self } do: {
+      block call: [tmp]
+      tmp = tmp + 1
+    }
+    self
+  }
+
+  def times: block offset: offset {
+    """
+    @block @Block@ to be called with each number between @offset and @self.
+    @offset Offset to be used as starting point of iteration.
+    @return @self.
+
+    Similar to #times: but starts at a given offset.
+    """
+
+    self times: |i| {
+      block call: [i + offset]
+    }
+  }
+}

data/lib/iteration.fy

@@ -1,12 +1,38 @@
 class Fancy {
   class BreakIteration : StdError {
-    read_slots: ['return_value]
-    def initialize: @return_value {}
+    """
+    Raised to break the current iteration.
+    It is rescued by Block#loop.
+
+    Example:
+        10 times: |i| {
+            i println
+            if: (i == 3) then: {
+              Fancy BreakIteration new raise!
+            }
+        }
+        \"Done!\" println
+
+    Produces:
+        0
+        1
+        2
+        3
+        Done!
+    """
+
+    read_slots: ['result]
+    def initialize: @result {}
   }
 
   class NextIteration : StdError {
-    read_slots: ['return_value]
-    def initialize: @return_value {}
+    """
+    Raised to continue with next iteration (and stopping the current one).
+    It is rescued by Block#loop.
+    """
+
+    read_slots: ['result]
+    def initialize: @result {}
   }
 
   class StopIteration : StdError {
@@ -15,17 +41,16 @@ class Fancy {
     It is rescued by Block#loop.
 
     Example:
-      {
-        'Hello println
-        StopIteration new raise!
-        'World println
-      } loop
-      'Done! println
+        {
+          'Hello println
+          Fancy StopIteration new raise!
+          'World println
+        } loop
+        'Done! println
 
     Produces:
-
-      Hello
-      Done!
+        Hello
+        Done!
     """
 
     def initialize { @result = nil }
@@ -35,23 +60,23 @@ class Fancy {
       """
       Returns the return value of the iterator.
 
-        o = Object new
-        def o each: block {
-          block call: 1
-          block call: 2
-          block call: 3
-          100
-        }
+          o = Object new
+          def o each: block {
+            block call: [1]
+            block call: [2]
+            block call: [3]
+            100
+          }
 
-        e = o to_enum
-        e next p #=> 1
-        e next p #=> 2
-        e next p #=> 3
-        try {
-          e next
-        } catch Fancy StopIteration => ex {
-          ex result p #=> 100
-        }
+          e = o to_enum
+          e next p #=> 1
+          e next p #=> 2
+          e next p #=> 3
+          try {
+            e next
+          } catch Fancy StopIteration => ex {
+            ex result p #=> 100
+          }
       """
 
       @result