fancy 0.7.0 → 0.8.0

data/lib/proxies.fy

@@ -0,0 +1,151 @@
+class Proxies {
+  class ProxyReceiver : Fancy BasicObject {
+    """
+    A ProxyReceiver is an object which proxies all message sends to it to 2 other objects.
+    It will send each message first to its @proxy instance variable and then to the @obj instance variable.
+    """
+
+    def initialize: @proxy for: @obj {
+      """
+      @proxy Proxy receiver for @obj.
+      @obj Original receiver object.
+
+      Initializes a new ProxyReceiver with @proxy for @obj.
+      """
+
+      self
+    }
+
+    def unknown_message: msg with_params: params {
+      """
+      @msg Incoming message name.
+      @params Paremeters of incoming message send.
+
+      Forwards all incoming messages to @self to @@proxy and then @@obj.
+      """
+
+      @proxy receive_message: msg with_params: params
+      @obj receive_message: msg with_params: params
+    }
+  }
+
+  Proxy = ProxyReceiver
+
+  class RespondsToProxy : Fancy BasicObject {
+    """
+    A RespondsToProxy is a Proxy that forwards any message sent to it to it's @target instance variable
+    only if it responds to that message. Any messages that @target doesn't respond to simply won't be sent
+    and @nil will be returned.
+    """
+
+    def initialize: @target {
+      """
+      @target Target receiver object.
+
+      Initializes a new RespondsToProxy for @target.
+      """
+
+      self
+    }
+
+    def unknown_message: msg with_params: params {
+      """
+      @msg Incoming message name.
+      @params Paremeters of incoming message send.
+
+      Forwards all incoming message to @self to @@target
+      only if @@target responds to them.
+      """
+
+      if: (@target responds_to?: msg) then: {
+        @target receive_message: msg with_params: params
+      }
+    }
+  }
+
+  class ActorProxy : Fancy BasicObject {
+    """
+    An ActorProxy is a Proxy that forwards any message sent to it to
+    it's @target object as a future send by default. If explicitly sent
+    an async message, it will forward the async send to @target,
+    returning @nil instead of a @FutureSend@, as expected.
+
+    Example:
+          ap = ActorProxy new: target_actor
+
+          # this:
+          f = ap some_future_send: an_arg
+          # is the same as:
+          f = target_actor @ some_future_send: an_arg
+
+          # and this:
+          ap @@ some_async_send: another_arg
+          # is the same as:
+          target_actor @@ some_async_send: another_arg
+    """
+
+    def initialize: @target
+
+    def send_future: m with_params: p {
+      @target send_future: m with_params: p
+    }
+
+    def send_async: m with_params: p {
+      @target send_async: m with_params: p
+    }
+
+    def unknown_message: m with_params: p {
+      @target send_future: m with_params: p
+    }
+  }
+
+  class DistributingProxy : Fancy BasicObject {
+    """
+    DistributingProxy is a Proxy that round-robin distributes messages to objects
+    in a @Fancy::Enumerable@ specified upon creation.
+
+    Example:
+          p = DistributingProxy new: [worker1, worker2, worker3, worker4]
+          loop: {
+            req = @input receive_request
+            p handle_request: req         # will be forwarded to worker1-4
+          }
+    """
+
+    def initialize {
+      ArgumentError raise: "Missing list of proxy targets"
+    }
+
+    def initialize: @targets {
+      @free = @targets to_a dup
+      @mutex = Mutex new
+      @waiting = ConditionVariable new
+    }
+
+    def __with_target__: block {
+      t = @mutex synchronize: {
+        { @waiting wait: @mutex } until: { @free empty? not }
+        @free shift
+      }
+      val = block call: [t]
+      @mutex synchronize: { @free << t; @waiting broadcast }
+      val
+    }
+
+    instance_methods reject: /^(:initialize|initialize:|__with_target__:|unknown_message:with_params:|send_async:with_params:|send_future:with_params:|__send__)$/ . each: |m| {
+      undef_method(m)
+    }
+
+    def unknown_message: m with_params: p {
+      __with_target__: @{ receive_message: m with_params: p }
+    }
+
+    def send_async: m with_params: p {
+      __with_target__: @{ send_async: m with_params: p }
+    }
+
+    def send_future: m with_params: p {
+      __with_target__: @{ send_future: m with_params: p }
+    }
+  }
+}

data/lib/rbx.fy

@@ -42,3 +42,4 @@ require: "rbx/actor"
 require: "rbx/mutex"
 require: "rbx/module"
 require: "rbx/proc"
+require: "rbx/compiled_method"

data/lib/rbx/actor.fy

@@ -8,25 +8,24 @@ class Actor {
   first-come, first-serve manner.
 
   Actors are used to implement asynchronous and future message sends in Fancy
-  using the @@ and @@@ syntax.
-
-  Example usage:
-
-      a = Actor spawn: {
-        loop: {
-          match Actor receive {
-            case 'hello -> \"Hello World\" println
-            case 'quit ->
-              \"OK, done!\" println
-              break # Quit loop and let actor die
+  using the @ and @@ syntax.
+
+  Example:
+        a = Actor spawn: {
+          loop: {
+            match Actor receive {
+              case 'hello -> \"Hello World\" println
+              case 'quit ->
+                \"OK, done!\" println
+                break # Quit loop and let actor die
+            }
           }
         }
-      }
 
-      10 times: {
-        a ! 'hello # send 'hello to actor asynchronously
-      }
-      a ! 'quit
+        10 times: {
+          a ! 'hello # send 'hello to actor asynchronously
+        }
+        a ! 'quit
   """
 
   alias_method(':!, '<<)
@@ -39,8 +38,7 @@ class Actor {
     @block @Block@ that represents the @Actor@'s code body to be executed in a new @Thread@.
     @return A new @Actor@ running @block in a seperate @Thread@.
 
-    Example usage:
-
+    Example:
           Actor spawn: {
             loop: {
               Actor receive println # print all incoming messages

data/lib/rbx/array.fy

@@ -5,8 +5,18 @@ class Array {
 
   def Array new: size with: default {
     """
+    @size Initial size of @Array@.
+    @default Default value of new @Array@. Inserted @size times.
+    @return New @Array@ with @size values of @default in it.
+
     Creates a new Array with a given size and default-value.
-    If @default is a @Block@, call that block for each element instead.
+    If @default is a @Block@, call it with each index instead and
+    store the return value.
+
+    Example:
+          Array new: 3 with: 'hello    # => ['hello, 'hello, 'hello]
+          # default can also be a block, taking the current index.
+          Array new: 3 with: @{ * 2 }  # => [0, 2, 4]
     """
 
     match default {
@@ -67,7 +77,7 @@ class Array {
     """
     @idx Index to set a value for.
     @obj Value (object) to be set at the given index.
-    @return @obj
+    @return @obj.
 
     Inserts a given object at a given index (position) in the Array.
     """
@@ -83,8 +93,13 @@ class Array {
     @return Index of the value passed in within the @Array@, or @nil, if value not present.
 
     Returns the index of an item (or nil, if it isn't in the @Array@).
+    If @item is a @Block@, it will return the index of an element for which it yields @true.
     """
-    index(item)
+
+    match item {
+      case Block -> index(&item)
+      case _ -> index(item)
+    }
   }
 
   def last: count {

data/lib/rbx/block.fy

@@ -47,8 +47,6 @@ class Block {
     @top_scope receiver: recv
   }
 
-  # Ugh. HACK.
-  # Use try/catch to deal with older and latest version of rbx (method got changed)
   def call_with_receiver: receiver {
     """
     @receiver Receiver (value of @self) when calling the @Block@.
@@ -63,11 +61,7 @@ class Block {
           b call_with_receiver: r2 # => String
     """
 
-    try {
-      return call_under(receiver, method() scope())
-    } catch {
-      return call_on_instance(receiver)
-    }
+    call_on_instance(receiver)
   }
 
   def call: args with_receiver: receiver {

data/lib/rbx/class.fy

@@ -3,9 +3,9 @@ class Class {
 
   def new {
     """
-    @return A new @Class@ subclassed from @Object@.
+    @return A new instance of @Class@ @self.
 
-    Creates a new @Class@ instance by subclassing @Object@.
+    Creates a new instance of @self calling @initialize.
     """
 
     obj = allocate()
@@ -14,16 +14,16 @@ class Class {
   }
 
   # calls initialize:, if defined
-  def new: superclass {
+  def new: arg {
     """
-    @superclass The superclass to inherit from.
-    @return A new @Class@ inherited from @superclass.
+    @arg Argument to @initialize:.
+    @return A new instance of @Class@ @self.
 
-    Creates a new @Class@ instance by subclassing @superclass.
+    Creates a new instance of @self calling @initialize:.
     """
 
     obj = allocate()
-    obj initialize: superclass
+    obj initialize: arg
     obj
   }
 
@@ -63,7 +63,10 @@ class Class {
     body.
     """
 
-    define_method(name message_name, &block)
+    match block {
+      case Block -> define_method(name message_name, &block)
+      case _ -> define_method(name message_name, block)
+    }
   }
 
   def undefine_method: name {
@@ -130,6 +133,10 @@ class Class {
     instance_method(name message_name)
   }
 
+  def has_method?: method_name {
+    lookup_method(method_name message_name) nil? not
+  }
+
   def alias_method_rbx: new_method_name for: old_method_name {
     """
     Rbx specific version of alias_method:for: due to bootstrap order
@@ -215,9 +222,47 @@ class Class {
   }
 
   def class_eval: str_or_block {
+    """
+    @str_or_block @String@ or @Block@ to be evaluated in the context of this @Class@.
+
+    Evaluates a given @String@ of Fancy code or a @Block@ in the class context of @self.
+    Useful for dynamically defining methods on a class etc.
+
+    Example:
+          Array class_eval: \"def foo { 'foo println }\"
+          [1,2,3] foo  # => prints 'foo
+    """
+
     match str_or_block {
       case Block -> class_eval(&str_or_block)
-      case _ -> class_eval(str_or_block)
+      case _ -> class_eval: { str_or_block to_s eval }
+    }
+  }
+
+  def expose_to_ruby: method_name as: ruby_method_name (nil) {
+    """
+    @method_name Fancy method name to be exposed.
+    @ruby_method_name Name of method exposed to Ruby (optional).
+
+    Explicitly exposes a Fancy method to Ruby. If @ruby_method_name is
+    passed, use that name explicitly, otherwise uses @method_name.
+
+    Example:
+          class Foo {
+            def === other {
+              # ...
+            }
+
+            expose_to_ruby: '===
+
+            # if you don't want to expose it as :=== in Ruby:
+            expose_to_ruby: '=== as: 'some_other_name_for_ruby
+          }
+    """
+
+    match ruby_method_name {
+      case nil -> alias_method(method_name, method_name message_name)
+      case _ -> alias_method(ruby_method_name, method_name message_name)
     }
   }
 }

data/lib/rbx/code_loader.fy

@@ -77,11 +77,8 @@ class Fancy {
           }
         }
         @@load_path each: |p| {
-          try {
-            if: (find_file: filename in_path: p) then: |f| {
-              return f
-            }
-          } catch {
+          if: (find_file: filename in_path: p) then: |f| {
+            return f
           }
         }
       }

data/lib/rbx/compiled_method.fy

@@ -0,0 +1,31 @@
+class Rubinius CompiledMethod {
+  forwards_unary_ruby_methods
+
+  def selectors_with_args {
+    local_names = local_names to_a
+    if: (required_args > 0) then: {
+      name to_s split: ":" . map_with_index: |sel i| {
+        "#{sel}: #{local_names[i]}"
+      } . join: " "
+    } else: {
+      name to_s rest
+    }
+  }
+
+  def definition_line {
+    # don't use documentation#to_s since we need original docstring as written in source file to calculate the correct lines#
+    docstring = ""
+    if: documentation then: {
+      docstring = documentation docs join: "\n"
+    }
+    if: (lines size > 3) then: {
+      lines[3] - (docstring lines size)
+    } else: {
+      0 # UNKNOWN?
+    }
+  }
+
+  def last_line {
+    defined_line
+  }
+}

data/lib/rbx/debugger.fy

@@ -0,0 +1,66 @@
+require("rubinius/debugger")
+
+class Rubinius Debugger {
+  forwards_unary_ruby_methods
+  metaclass forwards_unary_ruby_methods
+}
+
+class Rubinius Debugger Command SetBreakPoint {
+  def match_method: method_identifier {
+    match method_identifier {
+      case /##/ ->
+        class_name, method_name = method_identifier split: "##"
+        method_identifier = "#{class_name}::#{method_name message_name}"
+      case /#/ ->
+        class_name, method_name = method_identifier split: "#"
+        method_identifier = "#{class_name}##{method_name message_name}"
+    }
+
+    /([A-Z]\w*(?:::[A-Z]\w*)*)([.#]|::)([a-zA-Z0-9_\[\]:]+[!?=]?)(?:[:](\d+))?/ match: method_identifier
+  }
+
+  alias_method('match_method, 'match_method:)
+}
+
+class Rubinius Location {
+  forwards_unary_ruby_methods
+}
+
+class Rubinius Debugger Frame {
+  forwards_unary_ruby_methods
+
+  def describe {
+    arg_str = ""
+    recv = nil
+    loc = @location
+
+    if: (loc is_block) then: {
+      if: (method required_args == 0) then: {
+        recv = "{ } in #{loc describe_receiver}#{loc name}"
+      } else: {
+        block_args = method local_names join: ", "
+        recv = "|#{block_args}| { } in #{loc describe_receiver}#{loc name}"
+      }
+    } else: {
+      recv = loc describe
+    }
+
+    recv = recv replace: "#:" with: "#"
+    recv = recv replace: ".:" with: "##"
+    recv = recv replace: "." with: "##"
+
+    str = "#{recv} at #{loc method active_path}:#{loc line} (#{loc ip})"
+    { str << " (+#{loc ip})" } if: $ @debugger variables['show_ip]
+    str
+  }
+
+  alias_method('describe, ':describe)
+
+  def run: code {
+    Fancy eval: (code to_s) binding: binding
+  }
+
+  alias_method('run, 'run:)
+}
+
+Rubinius Debugger start