fancy 0.3.3 → 0.4.0

data/lib/stack.fy

@@ -4,48 +4,79 @@ class Stack {
   """
 
   def initialize {
+    """
+    Initializes a new Stack.
+    """
+
     @arr = []
   }
 
   def initialize: size {
-    "Initializes a new Stack with a given size."
+    """
+    @size Initial size of the new Stack.
+
+    Initializes a new Stack with a given size.
+    """
 
     @arr = Array new: size
   }
 
   def push: obj {
-    "Pushes a value onto the Stack."
-
-    @arr << obj
-  }
+    """
+    @obj Object to be pushed onto @self.
 
-  def << obj {
-    "Same as Stack#push:."
+    Pushes a value onto the Stack.
+    """
 
     @arr << obj
   }
 
+  alias_method: '<< for: 'push:
+
   def pop {
-    "Pops the top-of-stack element from the Stack and returns it."
+    """
+    @return Top-of-stack element.
+
+    Pops the top-of-stack element from the Stack and returns it.
+    """
 
     @arr remove_at: (size - 1)
   }
 
   def top {
-    "Returns the top-of-stack element."
+    """
+    @return The top-of-stack element.
+    """
 
     @arr last
   }
 
   def size {
-    "Returns the size of the Stack."
+    """
+    @return Size of the Stack.
+    """
 
     @arr size
   }
 
   def empty? {
-    "Indicates, if the Stack is empty."
+    """
+    @return @true if empty, otherwise @false.
+
+    Indicates, if the Stack is empty.
+    """
 
     @arr empty?
   }
+
+  def each: block {
+    """
+    @block @Block@ to be called with each element in @self.
+    @return @self.
+
+    Calls a given @Block@ with each element in @self, starting with the top of stack element.
+    """
+
+    @arr reverse each: block
+  }
 }

data/lib/string.fy

@@ -11,19 +11,33 @@ class String {
   include: FancyEnumerable
 
   def ++ other {
-    "Concatenate the String with another String"
+    """
+    @other Object to concatenate @self with as a @String@.
+    @return Concatenation of @self with @other.
+
+    Concatenate @self with another Object's @String@ representation.
+        \"foo\” ++ 42 # => \”foo42\”
+    """
 
     self + (other to_s)
   }
 
   def whitespace? {
-    "Indicates, if a String is empty or a single whitespace character."
+    """
+    @return @true, if @self consists only of a single whitespace character or is empty, @false otherwise.
+
+    Indicates, if a @String@ is empty or a single whitespace character.
+    """
 
     empty? or: (self == " ")
   }
 
   def blank? {
-    "Indicates, if a String consists only of whitespace."
+    """
+    @return @true if @self consists only of whitespace, @false otherwise.
+
+    Indicates, if a @String@ consists only of whitespace.
+    """
 
     self =~ /^\s*$/ if_true: {
       true
@@ -33,26 +47,122 @@ class String {
   }
 
   def * num {
-    "Returns a string that is the num-fold concatenation of itself."
+    """
+    @num Amount of concatenations to do with @self.
+    @return @String@ that is the num-fold concatenation of @self.
+
+    Returns a @String@ that is the num-fold concatenation of itself.
+        \"foo\" * 3 # => \”foofoofoo\"
+    """
 
     str = ""
     num to_i times: {
-      str = str ++ self
+      str << self
     }
     str
   }
 
   def words {
+    """
+    @return @Array@ of all the whitespace seperated words in @self.
+
+        \"hello world\" words  # => [\"hello\", \"world\"]
+    """
+
     split
   }
 
   def raise! {
-    "Raises a new StdError with self as the message."
-    StdError new: self . raise!
+    """
+    Raises a new @StandardError@ with self as the message.
+    """
+
+    StandardError new: self . raise!
   }
 
   def rest {
-    "Returns a @String@ containing all but the first character."
+    """
+    @return @String@ containing all but the first character.
+
+    Returns a @String@ containing all but the first character.
+        \"hello\" rest # => \"ello\"
+    """
+
     from: 1 to: -1
   }
+
+  def lines {
+    """
+    @return @Array@ of all the lines in @self.
+
+    Returns the lines of a @String@ as an @Array@.
+    """
+
+    split: "\n"
+  }
+
+  def << object {
+    """
+    @object An @Object@ who's @String@ representation will be appended to @self.
+    @return @self, but modified.
+
+    Appends @object's @String@ representation to @self.
+
+    Example usage:
+        str = \"hello\"
+        str << \" \"
+        str << 42
+        str # => \"hello 42\"
+    """
+
+    append: $ object to_s
+  }
+
+  def skip_leading_indentation {
+    """
+    Remove leading white space for multi-line strings.
+    This method expects the first character to be an line return.
+    """
+
+    str = self
+    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 characters {
+    """
+    @return @Array@ of all characters (as @String@) in @self.
+    """
+
+    scan: /./
+  }
+
+  def character {
+    """
+    @return @Fixnum@ (byte / ASCII) value of first character in @self.
+    """
+
+    self bytes each: |c| {
+      return c
+    }
+    return nil
+  }
+
+  def bytes {
+    """
+    @return @FancyEnumerator@ of all bytes (@Fixnum@ values) in @self.
+    """
+
+    enum = bytes()
+    def enum each: block {
+      each(&block)
+    }
+    FancyEnumerator new: enum
+  }
 }

data/lib/struct.fy

@@ -1,7 +1,17 @@
 class Struct {
-  def Struct new: fields {
-    struct = new(*fields)
-    struct read_write_slots: fields
+  """
+  Structs are light-weight classes with predefined read-writable slots.
+  """
+
+  def Struct new: slots {
+    """
+    @slots @Array@ of slotnames the new Struct should contain.
+
+    Creates a new Struct class with the given slots.
+    """
+
+    struct = new(*slots)
+    struct read_write_slots: slots
 
     def struct new: values {
       new(*values)

data/lib/symbol.fy

@@ -14,10 +14,29 @@ class Symbol {
     """
 
     if: (arg is_a?: Array) then: {
-      arg first send_message: self with_params: $ arg rest
+      arg first receive_message: self with_params: $ arg rest
     } else: {
-      arg send_message: self
+      arg receive_message: self
     }
   }
 
+  def call {
+    """
+    Sends @self as message to the sender in its context.
+    Example:
+        'foo call
+         # => same as
+         self foo
+
+         if: x then: 'foo else: 'bar
+         # same as:
+         if: x then: { self foo } else: { self bar }
+    """
+
+    binding = Binding setup(Rubinius VariableScope of_sender(),
+                            Rubinius CompiledMethod of_sender(),
+                            Rubinius StaticScope of_sender())
+    recv = binding self()
+    recv receive_message: self
+  }
 }

data/lib/thread_pool.fy

@@ -94,8 +94,9 @@ class ThreadPool {
     }
   }
 
-  def protected init_completable: block {
+  def init_completable: block {
     block extend(Completable)
     block complete: false
   }
+  protected: 'init_completable:
 }

data/lib/true_class.fy

@@ -1,39 +1,77 @@
 class TrueClass {
-  "TrueClass. The class of the singleton @true value."
+  """
+  TrueClass. The class of the singleton @true value.
+  """
 
   def TrueClass new {
+    """
+    @return @true.
+    """
+
     # always return true singleton object when trying to create a new
     # TrueClass instance
     true
   }
 
   def if_true: block {
-    "Calls @block."
+    """
+    @block @Block@ to be called with @self.
+    @return Value of calling @block with @self.
+
+    Calls @block with @self.
+    """
+
     block call: [self]
   }
 
   def if_true: then_block else: else_block {
-    "Calls @then_block."
+    """
+    @then_block @Block@ to be called with @self.
+    @else_block Gets ignored.
+    @return Value of calling @then_block with @self.
+
+    Calls @then_block with @self.
+    """
+
     then_block call: [self]
   }
 
   def true? {
-    "Returns @true."
+    """
+    @return @true.
+    """
+
     true
   }
 
   def to_s {
-    "Returns @true as a @String@."
+    """
+    @return @true as a @String@.
+    """
+
     "true"
   }
 
+  alias_method: 'inspect for: 'to_s
+
   def to_a {
-    "Returns an empty @Array@."
+    """
+    @return An empty @Array@.
+    """
+
     []
   }
 
   def not {
-    "Returns @false."
+    """
+    @return @false.
+    """
+
     false
   }
 }
+
+true documentation: """
+  @true is the singleton boolean true value (only instance of @TrueClass@).
+  TrueClass##new yields @true.
+  """

data/lib/tuple.fy

@@ -6,7 +6,7 @@ class Tuple {
 
   include: FancyEnumerable
 
-  def [] idx {
+  def [idx] {
     """
     Forwards to @Tuple@#at:.
     """
@@ -15,22 +15,34 @@ class Tuple {
   }
 
   def first {
-    "Returns the first element in the @Tuple@."
+    """
+    @return The first element in @self.
+    """
+
     at: 0
   }
 
   def second {
-    "Returns the second element in the @Tuple@."
+    """
+    @return The second element in @self.
+    """
+
     at: 1
   }
 
   def third {
-    "Returns the third element in the @Tuple@."
+    """
+    @return The third element in @self.
+    """
+
     at: 2
   }
 
   def fourth {
-    "Returns the fourth element in the @Tuple@"
+    """
+    @return The fourth element in @self.
+    """
+
     at: 3
   }
 
@@ -71,15 +83,17 @@ class Tuple {
   }
 
   def inspect {
-    "Returns a @String@ representation of a @Tuple@"
+    """
+    @return A @String@ representation of @self.
+    """
 
     str = "("
     each: |v| {
-      str = str ++ v
+      str << (v inspect)
     } in_between: {
-      str = str ++ ", "
+      str << ", "
     }
-    str = str ++ ")"
+    str << ")"
     str
   }
 
@@ -96,4 +110,8 @@ class Tuple {
       [obj] + (obj map: 'identity)
     }
   }
+
+  def Tuple name {
+    "Tuple"
+  }
 }