fancy 0.3.0

data/lib/rbx/integer.fy

@@ -0,0 +1,15 @@
+class Integer {
+  # common ruby-forwarding methods used by Fixnum & Bignum classes
+
+  def times: block {
+    times(&block)
+  }
+
+  def upto: num do_each: block {
+    upto(num, &block)
+  }
+
+  def downto: num do_each: block {
+    downto(num, &block)
+  }
+}

data/lib/rbx/io.fy

@@ -0,0 +1,30 @@
+class IO {
+  ruby_alias: 'readlines
+  ruby_alias: 'readline
+  ruby_alias: 'read
+  ruby_alias: 'close
+  ruby_alias: 'eof?
+
+  def readln {
+    self readline
+  }
+
+  def println {
+    self puts()
+  }
+
+  def print: obj {
+    self print(obj)
+  }
+
+  def println: obj {
+    self puts(obj)
+  }
+
+  def printchar: char {
+    self printc(char)
+  }
+
+  alias_method: 'write: for: 'print:
+  alias_method: 'writeln: for: 'println:
+}

data/lib/rbx/match_data.fy

@@ -0,0 +1,9 @@
+class MatchData {
+   def at: idx {
+     ruby: '[] args: [idx]
+   }
+
+   def [] idx {
+     at: idx
+   }
+}

data/lib/rbx/method.fy

@@ -0,0 +1,22 @@
+class Method {
+  def documentation {
+    Fancy Documentation for: (self executable())
+  }
+
+  def documentation: str {
+    Fancy Documentation for: (self executable()) is: str
+  }
+}
+
+class UnboundMethod {
+
+  def documentation {
+    Fancy Documentation for: (self executable())
+  }
+
+  def documentation: str {
+    Fancy Documentation for: (self executable()) is: str
+  }
+
+}
+

data/lib/rbx/name_error.fy

@@ -0,0 +1,3 @@
+class NameError {
+  ruby_alias: 'name
+}

data/lib/rbx/no_method_error.fy

@@ -0,0 +1,15 @@
+class NoMethodError {
+  """
+  Exception class that gets thrown when a method wasn't found within a class.
+  """
+
+  def method_name {
+    """
+    @return Name of the method not found (as @String@).
+
+    Returns the name of the method that was not found as a @String@.
+    """
+
+    self name to_s from: 1 to: -1
+  }
+}

data/lib/rbx/object.fy

@@ -0,0 +1,117 @@
+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: "+"
+}
+
+class Object {
+
+  ruby_alias: '==
+  ruby_alias: '===
+  ruby_alias: 'class
+
+  def initialize {
+    self initialize()
+  }
+
+  def dclone {
+    "Returns a deep clone of self using Ruby's Marshal class."
+    Marshal load: $ Marshal dump: self
+  }
+
+  def ++ other {
+    self to_s + (other to_s)
+  }
+
+  def to_s {
+    self to_s()
+  }
+
+  def inspect {
+    self inspect()
+  }
+
+  def set_slot: slotname value: val {
+    instance_variable_set("@" ++ slotname, val)
+  }
+
+  def get_slot: slotname {
+    instance_variable_get("@" ++ slotname)
+  }
+
+  def and: other {
+    """
+    Boolean conjunction.
+    Returns true if self and other are true, otherwise nil.
+    """
+
+    self if_do: {
+      other if_do: {
+        return true
+      }
+    }
+    return false
+  }
+
+  def or: other {
+    """
+    Boolean disjunction.
+    Returns true if either self or other is true, otherwise nil.
+    """
+    self if_do: {
+      return true
+    } else: {
+      other if_do: {
+        return true
+      }
+    }
+    return false
+  }
+
+  def define_singleton_method: name with: block {
+    self metaclass define_method: name with: block
+  }
+
+  def undefine_singleton_method: name {
+    self metaclass undefine_method: name
+  }
+
+  def is_a?: class {
+    "Indicates, if an object is an instance of a given Class."
+    is_a?(class)
+  }
+
+  def kind_of?: class {
+    "Indicates, if an object is an instance of a given Class."
+    kind_of?(class)
+  }
+
+  def send: message {
+    self send(message_name: message)
+  }
+
+  def send: message params: params {
+    ruby: (message_name: message) args: params
+  }
+
+  def message_name: symbol {
+    symbol = symbol to_s
+    if: (symbol includes?: ":") then: {
+      symbol
+    } else: {
+      ":" ++ symbol
+    }
+  }
+
+  def responds_to?: message {
+    self respond_to?(message_name: message)
+  }
+}

data/lib/rbx/range.fy

@@ -0,0 +1,15 @@
+class Range {
+  ruby_alias: 'to_a
+  ruby_alias: '==
+  ruby_alias: '===
+
+  include: FancyEnumerable
+
+  def initialize: start to: end {
+    initialize(start, end)
+  }
+
+  def each: block {
+    each(&block)
+  }
+}

data/lib/rbx/regexp.fy

@@ -0,0 +1,9 @@
+class Regexp {
+  def === string {
+    ruby: 'match args: [string]
+  }
+}
+
+class MatchData {
+  ruby_alias: '[]
+}

data/lib/rbx/string.fy

@@ -0,0 +1,63 @@
+class String {
+
+  # prepend a : to fancy version of ruby methods.
+  ruby_alias: '==
+  ruby_alias: 'upcase
+  ruby_alias: 'downcase
+  ruby_alias: '=~
+  ruby_alias: 'to_i
+  ruby_alias: 'to_f
+  ruby_alias: 'chomp
+
+  def [] index {
+    """Given an Array of 2 Numbers, it returns the substring between the given indices.
+       If given a Number, returns the character at that index."""
+
+    # if given an Array, interpret it as a from:to: range substring
+    if: (index is_a?: Array) then: {
+      from: (index[0]) to: (index[1])
+    } else: {
+      ruby: '[] args: [index] . chr
+    }
+  }
+
+  def from: from to: to {
+    ruby: '[] args: [(from .. to)]
+  }
+
+  def each: block {
+    split("") each(&block)
+  }
+
+  def at: idx {
+    self[idx]
+  }
+
+  def split: str {
+    split(str)
+  }
+
+  def split {
+    split()
+  }
+
+  def eval {
+    binding = Binding setup(Rubinius VariableScope of_sender(),
+                            Rubinius CompiledMethod of_sender(),
+                            Rubinius StaticScope of_sender())
+    Fancy eval: self binding: binding
+  }
+
+  def eval_global {
+    Fancy eval: self
+  }
+
+  def to_sexp {
+    "Not implemented yet!" raise!
+  }
+
+  def raise! {
+    "Raises a new StdError with self as the message."
+    StdError new: self . raise!
+  }
+}

data/lib/rbx/symbol.fy

@@ -0,0 +1,12 @@
+class Symbol {
+  def eval {
+    binding = Binding setup(Rubinius VariableScope of_sender(),
+                            Rubinius CompiledMethod of_sender(),
+                            Rubinius StaticScope of_sender())
+    Fancy eval: (self to_s) binding: binding
+  }
+
+  def inspect {
+    "'" ++ (inspect() from: 1 to: -1)
+  }
+}

data/lib/rbx/system.fy

@@ -0,0 +1,37 @@
+class System {
+  def System exit {
+    "Exit the running Fancy process."
+
+    Kernel exit()
+  }
+
+  def System do: command_str {
+    "Runs the given string as a system() command."
+
+    Kernel system(command_str)
+  }
+
+  def System piperead: command_str {
+    """
+    Runs the given string as a popen() call and returns the output
+    of the call as a string.
+    """
+
+    pipe: command_str . readlines map: 'chomp
+  }
+
+  def System pipe: command_str {
+    """
+    Runs the given string as a popen() call and returns a IO handle
+    that can be read from
+    """
+
+    IO popen(command_str)
+  }
+
+  def System sleep: n_ms {
+    "Sets the Fancy process for a given amount of milliseconds to sleep."
+
+    Kernel sleep(n_ms / 1000)
+  }
+}

data/lib/rbx/tcp_server.fy

@@ -0,0 +1,6 @@
+require("socket")
+
+class TCPServer {
+  " TCP Server "
+  ruby_alias: 'accept
+}

data/lib/rbx/tcp_socket.fy

@@ -0,0 +1,7 @@
+require("socket")
+
+class TCPSocket {
+  def TCPSocket open: server port: port {
+    open(server, port)
+  }
+}

data/lib/rbx/thread.fy

@@ -0,0 +1,75 @@
+require("thread")
+
+class Thread {
+  """
+  Thread class.
+  Deals with parallel execution.
+
+  TODO:
+  => Still need to add more Fancy-ish wrapper methods and method
+     documentation.
+  """
+
+  ruby_alias: 'abort_on_exception
+  ruby_alias: 'join
+  ruby_alias: 'run
+  ruby_alias: 'alive?
+  ruby_alias: 'exit
+  ruby_alias: 'exit!
+  ruby_alias: 'kill
+#  ruby_alias: 'kill!
+  ruby_alias: 'terminate
+#  ruby_alias: 'terminate!
+  ruby_alias: 'priority
+#  ruby_alias: 'safe_level
+  ruby_alias: 'status
+  ruby_alias: 'stop?
+  ruby_alias: 'value
+  ruby_alias: 'wakeup
+
+  Thread metaclass ruby_alias: 'abort_on_exception
+  Thread metaclass ruby_alias: 'current
+  Thread metaclass ruby_alias: 'critical
+  Thread metaclass ruby_alias: 'exit
+  Thread metaclass ruby_alias: 'list
+  Thread metaclass ruby_alias: 'main
+  Thread metaclass ruby_alias: 'pass
+  Thread metaclass ruby_alias: 'stop
+
+  def priority: new_prio {
+    priority=(new_prio)
+  }
+
+  def raise: exception {
+    raise(exception)
+  }
+
+  def exclusive: block {
+    exclusive(&block)
+  }
+
+  def Thread new: block {
+    new(&block)
+  }
+
+  def Thread abort_on_exception: abort_on_exception {
+    abort_on_exception=(abort_on_exception)
+  }
+
+  def abort_on_exception: abort_on_exception {
+    abort_on_exception=(abort_on_exception)
+  }
+
+  def Thread critical: critical {
+    critical=(critical)
+  }
+
+  def Thread kill: thread {
+    kill(thread)
+  }
+
+  def Thread start: block {
+    start(&block)
+  }
+
+}