fancy 0.3.3 → 0.4.0

data/lib/proxy.fy

@@ -5,11 +5,26 @@ class ProxyReceiver : BasicObject {
   """
 
   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 {
-    @proxy send_message: msg with_params: params
-    @obj send_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
   }
 }
 
@@ -23,11 +38,26 @@ class RespondsToProxy : BasicObject {
   """
 
   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 send_message: msg with_params: params
+      @target receive_message: msg with_params: params
     }
   }
 }

data/lib/range.fy

@@ -0,0 +1,28 @@
+class Range {
+  """
+  Class of Range values. Are created by using Range literal syntax in Fancy.
+
+  Example:
+      (10..100) # Range from 10 to 100
+      # the following code does the same as above:
+      Range new: 10 to: 100
+  """
+
+  include: FancyEnumerable
+
+  def to_s {
+    """
+    Same as Range#inspect
+    """
+
+    inspect
+  }
+
+  def inspect {
+    """
+    @return @String@ representation of @self.
+    """
+
+    "(" ++ @start ++ ".." ++ @end ++ ")"
+  }
+}

data/lib/rbx.fy

@@ -5,6 +5,7 @@
 # NOTE:
 # Don't change the order in here, unless you know what you're doing.
 
+require: "rbx/alpha"
 require: "rbx/documentation"
 require: "rbx/object"
 require: "rbx/class"
@@ -26,14 +27,15 @@ require: "rbx/io"
 require: "rbx/file"
 require: "rbx/tcp_server"
 require: "rbx/tcp_socket"
+require: "rbx/match_data"
 require: "rbx/regexp"
 require: "rbx/directory"
 require: "rbx/method"
 require: "rbx/environment_variables"
 require: "rbx/name_error"
 require: "rbx/no_method_error"
-require: "rbx/match_data"
 require: "rbx/thread"
 require: "rbx/fiber"
 require: "rbx/date"
 require: "rbx/time"
+require: "rbx/actor"

data/lib/rbx/actor.fy

@@ -0,0 +1,53 @@
+require("actor")
+
+class Actor {
+  """
+  Primitive Actor class.
+  Actors can be sent messages asynchronously. They process incoming messages
+  (which can be any object, including Tuples, Arrays, Numbers ...) in a
+  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
+          }
+        }
+      }
+
+      10 times: {
+        a ! 'hello # send 'hello to actor asynchronously
+      }
+      a ! 'quit
+  """
+
+  alias_method(':!, '<<)
+
+  forwards_unary_ruby_methods
+  metaclass forwards_unary_ruby_methods
+
+  def Actor spawn: block {
+    """
+    @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:
+
+        Actor spawn: {
+          loop: {
+            Actor receive println # print all incoming messages
+          }
+        }
+    """
+
+    Actor spawn(&block)
+  }
+}

data/lib/rbx/alpha.fy

@@ -0,0 +1,31 @@
+class Object {
+  # Let's define false, true & nil =)
+  dynamic_method(':false) |g| {
+    g push_false()
+    g ret()
+  }
+
+  dynamic_method(':true) |g| {
+    g push_true()
+    g ret()
+  }
+
+  dynamic_method(':nil) |g| {
+    g push_nil()
+    g ret()
+  }
+}
+
+class Class {
+  def alias_method: new for: old {
+    alias_method(new, old)
+  }
+
+  def ruby_alias: method_name {
+    alias_method(":" + (method_name to_s), method_name)
+  }
+}
+
+class String {
+  alias_method: ":+" for: "+"
+}

data/lib/rbx/array.fy

@@ -1,17 +1,12 @@
 class Array {
   ruby_alias: '==
   ruby_alias: '<<
-  ruby_alias: 'clear
-  ruby_alias: 'size
-  ruby_alias: 'reverse
-  ruby_alias: 'reverse!
-  ruby_alias: 'sort
   ruby_alias: 'pop
   ruby_alias: 'last
-  ruby_alias: 'shuffle
-  ruby_alias: 'inspect
   ruby_alias: 'shift
 
+  forwards_unary_ruby_methods
+
   def Array new: size with: default {
     "Creates a new Array with a given size and default-value."
 
@@ -19,7 +14,12 @@ class Array {
   }
 
   def includes?: obj {
-    "Indicates, if an Array includes a given value."
+    """
+    @obj Object to search for in @self.
+    @return @true, if @obj is in @self, @false otherwise.
+
+    Indicates, if an Array includes a given value.
+    """
 
     include?(obj)
   }
@@ -61,7 +61,7 @@ class Array {
     at(idx)
   }
 
-  def at: idx put: obj {
+  def [idx]: obj {
     """
     @idx Index to set a value for.
     @obj Value (object) to be set at the given index.
@@ -72,6 +72,8 @@ class Array {
     ruby: '[]= args: [idx, obj]
   }
 
+  alias_method: 'at:put: for: '[]:
+
   def index: item {
     """
     @item Item/Value for which the index is requested within an @Array@.
@@ -122,15 +124,22 @@ class Array {
   }
 
   def reject!: block {
-    "Same as Array#reject: but doing so in-place (destructive)."
+    """
+    Same as Array#reject: but doing so in-place (destructive).
+    """
 
     reject!(&block)
     return self
   }
 
   def join: join_str {
-    """Joins all elements in the Array by a given String.
-       E.g.: [1,2,3] join: ', ' # => '1,2,3'"""
+    """
+    @join_str @String@ by which to @join all elements in @self into a new @String@.
+    @return Joined @String@ with all elements with @join_str.
+
+    Joins all elements in the Array with a given @String@.
+        [1,2,3] join: \", \” # => \”1, 2, 3\"
+    """
 
     join(join_str)
   }

data/lib/rbx/bignum.fy

@@ -1,4 +1,8 @@
 class Bignum {
+  """
+  Class for large integer values in Fancy.
+  """
+
   include: Number
 
   ruby_alias: '==
@@ -11,11 +15,11 @@ class Bignum {
   ruby_alias: '<=
   ruby_alias: '>=
   ruby_alias: '===
-  ruby_alias: 'chr
-  ruby_alias: 'to_i
   ruby_alias: '**
   ruby_alias: '&
 
+  forwards_unary_ruby_methods
+
   alias_method: 'to_s: for: 'to_s
   alias_method: 'modulo: for: 'modulo
   alias_method: ":%" for: "modulo:"  # prepend with : so we dont overwrite ruby's % operator

data/lib/rbx/block.fy

@@ -1,17 +1,8 @@
 # Block = BlockEnvironment
 
 class Block {
-  ruby_alias: 'arity
-
-  def argcount {
-    """
-    @return Arity of a @Block@.
-
-    Returns the amount of arguments (arity) a Block takes.
-    """
-
-    arity()
-  }
+  forwards_unary_ruby_methods
+  metaclass forwards_unary_ruby_methods
 
   def receiver {
     """
@@ -31,32 +22,38 @@ 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 {
-    call_under(receiver, method() scope())
+    try {
+      return call_under(receiver, method() scope())
+    } catch {
+      return call_on_instance(receiver)
+    }
   }
 
   def call: args with_receiver: receiver {
-    call_under(receiver, method() scope(), *args)
+    try {
+      return call_under(receiver, method() scope(), *args)
+    } catch {
+      return call_on_instance(receiver, *args)
+    }
   }
 
-  def loop {
-    wrapper = {
-      try {
-        call
-      } catch (Fancy NextIteration) => ex {
-        ex return_value
-      }
-    }
+  def to_proc {
+    """
+    @return Ruby Proc representing @self.
 
-    try {
-      loop(&wrapper)
-    } catch (Fancy BreakIteration) => ex {
-      return ex return_value
-    }
+    Turns a @Block@ into a Ruby Proc object.
+    """
+
+    Proc new(&self)
   }
 }
 
 class Rubinius VariableScope {
+  forwards_unary_ruby_methods
+
   def receiver {
     @self
   }

data/lib/rbx/class.fy

@@ -4,6 +4,8 @@ class Class {
   ruby_alias: 'ancestors
   ruby_alias: 'instance_methods
   ruby_alias: 'methods
+  ruby_alias: 'inspect
+  ruby_alias: 'to_s
 
   def new {
     """
@@ -37,8 +39,8 @@ class Class {
     @body_block A @Block@ that is used as the body of the new @Class@.
     @return A new @Class@ inherited from @superclass.
 
-    Creates a new @Class@ by subclassing @superclass and using
-    @body_block as its body.
+    Creates a new @Class@ by subclassing @superclass and
+    using @body_block as its body.
     """
 
     new(superclass, &body_block)
@@ -149,4 +151,54 @@ class Class {
     """
     alias_method(message_name: new_method_name, ruby_method_name)
   }
+
+  def public: method_names {
+    """
+    @method_names One or more (@Array@) method names (as a @Symbol@) to be set to public in this @Class@.
+
+    Sets any given method names to public on this @Class@.
+    """
+
+    method_names = method_names to_a()
+    method_names = method_names map: |m| { message_name: m }
+    public(*method_names)
+  }
+
+  def private: method_names {
+    """
+    @method_names One or more (@Array@) method names (as a @Symbol@) to be set to private in this @Class@.
+
+    Sets any given method names to private on this @Class@.
+    """
+
+    method_names = method_names to_a()
+    method_names = method_names map() |m| { message_name: m }
+    private(*method_names)
+  }
+
+  def protected: method_names {
+    """
+    @method_names One or more (@Array@) method names (as a @Symbol@) to be set to protected in this @Class@.
+
+    Sets any given method names to protected on this @Class@.
+    """
+
+    method_names = method_names to_a()
+    method_names = method_names map() |m| { message_name: m }
+    protected(*method_names)
+  }
+
+  def forwards_unary_ruby_methods {
+    """
+    Creates ruby_alias methods for any unary ruby methods of a class.
+    """
+
+    instance_methods select() |m| {
+      m =~(/^[a-z]+/)
+    } select() |m| {
+      instance_method(m) arity() == 0
+    } each() |m| {
+      ruby_alias: m
+    }
+  }
 }

data/lib/rbx/code_loader.fy

@@ -100,7 +100,7 @@ class Fancy {
     }
 
     # Returns the compiled filename for a given filename.
-    # E.g. "foo.fy" => "foo.fyc", "foo" => "foo.compiled.rbc"
+    # E.g. "foo.fy" => "foo.fyc", "foo" => "foo.compiled.fyc"
     def self compiled_filename_for: file {
       match file {
         case /\.fyc$/ -> file
@@ -121,7 +121,7 @@ class Fancy {
           # Rubinius::Compiler.compile_fancy_file filename, nil, 1, false
           Compiler compile_file: filename to: compiled_file
         } else: {
-          @@compiled at: filename put: true
+          @@compiled[filename]: true
         }
       }
       compiled_file
@@ -153,10 +153,14 @@ class Fancy {
         dirname = File dirname(compiled_file)
         push_loadpath: dirname
         @@current_dir push(dirname)
-        @@loaded at: compiled_file put: true
+        @@loaded[compiled_file]: true
 
         cl = Rubinius::CodeLoader new(compiled_file)
-        cm = cl load_compiled_file(compiled_file, 0)
+        try {
+          cm = cl load_compiled_file(compiled_file, 0)
+        } catch ArgumentError {
+          cm = cl load_compiled_file(compiled_file, 0, 0)
+        }
 
         script = cm create_script(false)
         script file_path=(source_file)