fancy 0.5.0 → 0.6.0

data/lib/future.fy

@@ -5,6 +5,7 @@ class FutureSend {
     @condvar = ConditionVariable new
     @completed = false
     @failed = false
+    @continuations = []
     @actor ! ('future, (@message, @params), self)
   }
 
@@ -26,11 +27,19 @@ class FutureSend {
 
   def completed! {
     @condvar broadcast
+    unless: @failed do: {
+      @continuations each: @{ call: [@value] }
+    }
+    @continuations = []
   }
 
   private: 'completed!
 
   def completed? {
+    """
+    @return @true if FutureSend completed (success or failure), @false otherwise.
+    """
+
     completed = false
     @completed_mutex synchronize: {
       completed = @completed
@@ -38,7 +47,25 @@ class FutureSend {
     return completed true?
   }
 
+  def succeeded? {
+    """
+    @return @true if FutureSend completed without failure, @false otherwise.
+    """
+
+    completed = false
+    failed = false
+    @completed_mutex synchronize: {
+      completed = @completed
+      failed = @failed
+    }
+    return completed true? && (failed false?)
+  }
+
   def failed? {
+    """
+    @return @true if FutureSend failed, @false otherwise.
+    """
+
     failed = false
     @completed_mutex synchronize: {
       failed = @failed
@@ -47,6 +74,13 @@ class FutureSend {
   }
 
   def failure {
+    """
+    @return @Exception@ that caused the FutureSend to fail, or @nil, if no failure.
+
+    Returns the @Exception@ that caused @self to fail, or @nil, if it didn't fail.
+    Will block the calling @Thread@ if @self hasn't completed or failed yet.
+    """
+
     @completed_mutex synchronize: {
       if: @failed then: {
         return @fail_reason
@@ -58,6 +92,13 @@ class FutureSend {
   }
 
   def value {
+    """
+    @return Return value of performing @self.
+
+    Returns the value returned by performing @self.
+    Will block the calling @Thread@ if @self hasn't completed or failed yet.
+    """
+
     @completed_mutex synchronize: {
       if: @completed then: {
         return @value
@@ -73,9 +114,24 @@ class FutureSend {
   }
 
   def when_done: block {
-    block send_future: 'call: with_params: [value]
+    """
+    @block @Block@ to be registered as a continuation when @self succeeds.
+
+    Registers @block as a continuation to be called with @self's value on success.
+    """
+
+    { return nil } if: failed?
+    @completed_mutex synchronize: {
+      if: @completed then: {
+        block call: [@value]
+      } else: {
+        @continuations << block
+      }
+    }
   }
 
+  alias_method: 'with_value: for: 'when_done:
+
   def && block {
     when_done: block
   }
@@ -132,15 +188,13 @@ class PooledFuture {
 }
 
 class FutureCollection {
-  include: FancyEnumerable
+  include: Fancy Enumerable
 
   def initialize: @futures {
   }
 
   def each: block {
-    @futures each: |f| {
-      f when_done: block
-    }
+    @futures each: @{ when_done: block }
   }
 
   def await_all {

data/lib/hash.fy

@@ -4,7 +4,7 @@ class Hash {
   Maps a key to a value.
   """
 
-  include: FancyEnumerable
+  include: Fancy Enumerable
 
   def [key] {
     """
@@ -17,6 +17,21 @@ class Hash {
     at: key
   }
 
+  def at: key else: else_block {
+    """
+    @key Key of the value to get.
+    @else_block @Block@ to be called if @key is not found.
+    @return Value for @key or value of calling @else_block, if @key is not found.
+
+    Returns the value for a given key.
+    If the key is not found, calls @else_block and returns the value it yields.
+    """
+
+    if: (includes?: key) then: {
+      at: key
+    } else: else_block
+  }
+
   def each: block {
     """
     @block @Block@ to be called with each key and value in @self.
@@ -80,6 +95,26 @@ class Hash {
     to_a to_s
   }
 
+  def to_object {
+    """
+    @return New @Object@ with slots defined by keys and values in @self.
+
+    Creates and returns a new @Object@ with slot names and values based on keys and values in @self.
+
+    Example:
+          o = <['name => \"Christopher Bertels\", 'interest => \"programming languages\"]> to_object
+          o name        # => \"Christopher Bertels\"
+          o interest    # => 42
+    """
+
+    o = Object new
+    self each: |k v| {
+      o set_slot: k value: v
+    }
+    o metaclass read_write_slots: keys
+    o
+  }
+
   def inspect {
     str = "<["
     each: |key val| {
@@ -104,4 +139,22 @@ class Hash {
 
     keys map: |k| { at: k }
   }
+
+  def fetch: key else: else_block {
+    """
+    @key Key of value to get.
+    @else_block @Block@ that gets called if @key not in @self.
+
+    Example:
+          <['foo => 'bar]> fetch: 'foo else: { 42 } # => 'bar
+          <['foo => 'bar]> fetch: 'unknown else: { 42 } # => 42
+          <['nil => nil]> fetch: 'nil else: { 'not_found } # => nil
+    """
+
+    if: (includes?: key) then: {
+      at: key
+    } else: {
+      else_block call: [key]
+    }
+  }
 }

data/lib/html.fy

@@ -0,0 +1,107 @@
+class HTML {
+  """
+  HTML generator class.
+
+  Example:
+        require: \"html\"
+        html = HTML new: @{
+          html: @{
+            head: @{ title: \"My Fancy Website\" }
+            body: @{
+              div: { id: \”main\” } with: \"Hello, Fancy World!\"
+            }
+          }
+        } . to_s
+
+        # html is now:
+        \"\"\"
+        <html>
+          <head>
+            <title>
+              My Fancy Website
+            </title>
+          </head>
+          <body>
+            <div id=\"main\">
+              Hello, Fancy World!
+            </div>
+          </body>
+        </html>
+        \"\"\"
+
+  """
+
+  def initialize {
+    @buf = ""
+    @indent = 0
+  }
+
+  def initialize: block {
+    initialize
+    block call: [self]
+  }
+
+  def open_tag: name attrs: attrs (<[]>) indent: indent (true) {
+    @buf << "\n"
+    @buf << (" " * @indent)
+    @indent = @indent + 2
+
+    @buf << "<" << name
+    unless: (attrs empty?) do: {
+      @buf << " "
+      attrs each: |k v| {
+        @buf << k << "=" << (v to_s inspect)
+      } in_between: {
+        @buf << " "
+      }
+    }
+    @buf << ">"
+
+    { @indent = @indent - 2 } unless: indent
+  }
+
+  def close_tag: name {
+    @buf << "\n"
+    @indent = @indent - 2
+    @buf << (" " * @indent)
+
+    @buf << "</" << name << ">"
+  }
+
+  def html_block: tag body: body attrs: attrs (<[]>) {
+    tag = tag from: 0 to: -2
+    open_tag: tag attrs: attrs
+    match body first {
+      case Block -> @buf << (body first call: [self])
+      case _ -> @buf << "\n" << (" " * @indent) << (body first)
+    }
+    close_tag: tag
+    nil
+  }
+
+  def unknown_message: m with_params: p {
+    match m to_s {
+      case /with:$/ ->
+        tag = m to_s substitute: /with:$/ with: ""
+        html_block: tag body: (p rest) attrs: (p first to_hash)
+      case _ ->
+        html_block: (m to_s) body: p
+    }
+    nil
+  }
+
+  def br {
+    @buf << "\n" << (" " * @indent)
+    @buf << "<br/>"
+    nil
+  }
+
+  def input: attrs {
+    open_tag: "input" attrs: (attrs to_hash) indent: false
+    nil
+  }
+
+  def to_s {
+    @buf from: 1 to: -1 . to_s
+  }
+}

data/lib/kvo.fy

@@ -0,0 +1,173 @@
+class KVO {
+  """
+  Key-Value Observing Mixin class.
+  Include this Class into any class to add support for Key-Value Observing.
+  Inspired by Objective-C's KVO, but using @Block@s, as it fits nicer
+  with Fancy's semantics.
+
+  Example:
+        class Person {
+          include: KVO
+          read_write_slots: ('name, 'age, 'city)
+        }
+
+        tom = Person new tap: @{
+          name: \"Tom Cruise\"
+          age: 55
+          city: \"Hollywood\"
+        }
+
+        tom observe: 'name with: |new old| {
+          new println
+        }
+        tom name: \"Tommy Cruise\"              # will cause \"Tommy Cruise\" to be printed
+        tom age: 56                           # No observer Blocks defined, so nothing will happen
+  """
+
+  class ClassMethods {
+    def define_slot_writer: slotname {
+      slotname = slotname to_sym
+      define_method: "#{slotname}:" with: |new_val| {
+        old_val = get_slot: slotname
+        set_slot: slotname value: new_val
+        match new_val {
+          case old_val -> nil # do nothing if no change
+          case _ ->
+            __kvo_slot_change__: slotname new: new_val old: old_val
+        }
+      }
+    }
+
+    def define_slot_reader: slotname {
+      slotname = slotname to_sym
+      define_method: slotname with: {
+        val = get_slot: slotname
+        if: (val is_a?: Fancy Enumerable) then: {
+          unless: (val get_slot: '__kvo_wrappers_defined?__) do: {
+            __kvo_wrap_collection_methods__: val for_slot: slotname
+          }
+        }
+        val
+      }
+    }
+  }
+
+  def KVO included: class {
+    class extend: ClassMethods
+  }
+
+  def observe: slotname with: block {
+    """
+    @slotname Name of slot to be observed with @block.
+    @block @Block@ to be called with old and new value of @slotname in @self.
+
+    Registers a new observer @Block@ for @slotname in @self.
+    """
+
+    __kvo_add_observer__: block for: slotname to: __kvo_slot_observers__
+  }
+
+  def observe_insertion: slotname with: block {
+    """
+    @slotname Name of collection slot to be observed with @block.
+    @block @Block@ to be called with value inserted in collection named @slotname in @self.
+
+    Registers a new insertion observer @Block@ for collection named @slotname in @self.
+    """
+
+    __kvo_add_observer__: block for: slotname to: __kvo_insertion_observers__
+  }
+
+  def observe_removal: slotname with: block {
+    """
+    @slotname Name of collection slot to be observed with @block.
+    @block @Block@ to be called with value removed from collection named @slotname in @self.
+
+    Registers a new removal observer @Block@ for collection named @slotname in @self.
+    """
+
+    __kvo_add_observer__: block for: slotname to: __kvo_removal_observers__
+  }
+
+  # PRIVATE METHODS
+  # OMG this looks FUGLY but this shall never be seen anyway
+
+  def __kvo_slot_observers__ {
+    { @__kvo_slot_observers__ = <[]> } unless: @__kvo_slot_observers__
+    @__kvo_slot_observers__
+  }
+
+  private: '__kvo_slot_observers__
+
+  def __kvo_insertion_observers__ {
+    { @__kvo_insertion_observers__ = <[]> } unless: @__kvo_insertion_observers__
+    @__kvo_insertion_observers__
+  }
+  private: '__kvo_insertion_observers__
+
+  def __kvo_removal_observers__ {
+    { @__kvo_removal_observers__ = <[]> } unless: @__kvo_removal_observers__
+    @__kvo_removal_observers__
+  }
+  private: '__kvo_removal_observers__
+
+  def __kvo_add_observer__: block for: slotname to: observer_list {
+    slotname = slotname to_sym
+    if: (observer_list[slotname]) then: |set| {
+      set << block
+    } else: {
+      observer_list[slotname]: $ Set new: [block]
+    }
+  }
+  private: '__kvo_add_observer__:for:to:
+
+  def __kvo_slot_change__: slotname new: new_val old: old_val {
+    if: (__kvo_slot_observers__[slotname]) then: @{
+      each: @{ call: [new_val, old_val] }
+    }
+  }
+  private: '__kvo_slot_change__:new:old:
+
+  def __kvo_insertion__: value for_slot: slotname {
+    if: (__kvo_insertion_observers__[slotname]) then: @{
+      each: @{ call: [value] }
+    }
+  }
+
+  def __kvo_removal__: value for_slot: slotname {
+    if: (__kvo_removal_observers__[slotname]) then: @{
+      each: @{ call: [value] }
+    }
+  }
+
+  def __kvo_wrap_collection_methods__: collection for_slot: slotname {
+    object = self
+    collection metaclass tap: |c| {
+      try {
+        c alias_method: '__insert__: for: '<<
+        c define_method: '<< with: |val| {
+          __insert__: val
+          object __kvo_insertion__: val for_slot: slotname
+        }
+      } catch {}
+
+      try {
+        c alias_method: '__remove__: for: 'remove:
+        c define_method: 'remove: with: |val| {
+          __remove__: val
+          object __kvo_removal__: val for_slot: slotname
+        }
+      } catch {}
+
+      try {
+        c alias_method: '__remove_at__: for: 'remove_at:
+        c define_method: 'remove_at: with: |index| {
+          obj = __remove_at__: index
+          object __kvo_removal__: obj for_slot: slotname
+        }
+      } catch {}
+    }
+    collection set_slot: '__kvo_wrappers_defined?__ value: true
+  }
+  private: '__kvo_wrap_collection_methods__:for_slot:
+}