fancy 0.3.0

data/lib/parser/methods.fy

@@ -0,0 +1,297 @@
+class Fancy {
+  class Parser {
+
+    def self parse_file: filename line: line (1) {
+      new: filename line: line . parse_file . script
+    }
+
+    def self parse_code: code file: filename line: line (1) {
+      new: filename line: line . parse_string: code . script
+    }
+
+    read_write_slots: ['filename, 'line, 'script]
+
+    def initialize: @filename line: @line { }
+
+    def body: body {
+      @script = AST Script new: @line file: @filename body: body
+    }
+
+    def ast: line exp_list: expr into: list (AST ExpressionList new: line) {
+      { list expressions << expr } if: expr
+      list
+    }
+
+    def ast: line identity: identity { identity }
+
+    def ast: line concat: object into: ary ([]) {
+      if: (object kind_of?(Array)) then: {
+        ary concat(object)
+      } else: {
+        { ary << object } if: object
+      }
+      ary
+    }
+
+    def ast: line key: key value: value into: ary {
+      ary if_nil: { ary = [] }
+      ary << key
+      ary << value
+      ary
+    }
+
+    def ast: line fixnum: text base: base (10) {
+      AST FixnumLiteral new: line value: (text to_i(base))
+    }
+
+    def ast: line number: text base: base (10) {
+      AST NumberLiteral new: line value: (text to_f())
+    }
+
+    def ast: line symbol: text {
+      str = text from: 1 to: -1
+      AST SymbolLiteral new: line value: (str to_sym())
+    }
+
+    def ast: line regexp: text {
+      regexp = text from: 1 to: -2
+      AST RegexpLiteral new: line value: regexp
+    }
+
+    def ast: line string: text {
+      str = text from: 1 to: -2
+      match str -> {
+        # OK, I know this is ugly. But it works for now, so let's just go with it.
+        # TODO: Clean this up or make it simpler...
+
+        # this case handles string interpolation
+        case /(.*)#{(.*)}(.*)/ -> |matches|
+          prefix = matches[1]
+          interpol_str = matches[2]
+          suffix = matches[3]
+
+          binding = AST MessageSend new: line message: (ast: line identifier: "binding") to: (AST Self new: line) args: (AST RubyArgs new: line args: [])
+          evalstr = AST StringLiteral new: line value: interpol_str
+          msg = ast: line identifier: "eval:binding:"
+          binding_send = AST MessageSend new: line message: msg to: (ast: line identifier: "Fancy") \
+                                         args: (AST MessageArgs new: line args: [evalstr, binding])
+
+          prefix_str = ast: line string: (" " + prefix + " ") # hack, pre- & append " " since it gets removed
+          suffix_str = ast: line string: (" " + suffix + " ")
+          # create messagesend to concatenate:
+          concat_ident = ast: line identifier: "++"
+          concat_prefix_send = AST MessageSend new: line message: concat_ident to: prefix_str args: (AST MessageArgs new: line args: [binding_send])
+          concat_suffix_send = AST MessageSend new: line message: concat_ident to: concat_prefix_send args: (AST MessageArgs new: line args: [suffix_str])
+
+          concat_suffix_send # this shall get returned, yo
+        case _ ->
+          AST StringLiteral new: line value: str
+      }
+    }
+
+    def ast: line array: expr_ary {
+      AST ArrayLiteral new: line array: expr_ary
+    }
+
+    def ast: line hash: key_values {
+      AST HashLiteral new: line entries: key_values
+    }
+
+    def ast: line tuple: expr_ary {
+      if: (expr_ary size == 1) then: {
+        expr_ary first
+      } else: {
+        AST TupleLiteral new: line entries: expr_ary
+      }
+    }
+
+    def ast: line range: from to: to {
+      AST RangeLiteral new: line from: from to: to
+    }
+
+    def ast: line identifier: text {
+      AST Identifier from: text line: line filename: @filename
+    }
+
+    def ast: line constant: identifier parent: parent {
+      AST NestedConstant new: line const: identifier parent: parent
+    }
+
+    def ast: line super_exp: text { AST Super new: line }
+
+    def ast: line retry_exp: text { AST Retry new: line }
+
+    def ast: line return_stmt: exp {
+      { exp = AST NilLiteral new: exp } if: (exp nil?)
+      AST Return new: line expr: exp
+    }
+
+    def ast: line return_local_stmt: exp {
+      { exp = AST NilLiteral new: exp } if: (exp nil?)
+      AST ReturnLocal new: line expr: exp
+    }
+
+    def ast: line assign: rvalue to: lvalue many: many (false) {
+      ast = many if_do: { AST MultipleAssignment } else: { AST Assignment }
+      ast new: line var: lvalue value: rvalue
+    }
+
+    def ast: line param: selector var: variable default: default (nil) {
+      Struct.new('selector, 'variable, 'default) new(selector, variable, default)
+    }
+
+    def ast: line send: selector arg: value ary: ary ([]) {
+      ary << $ Struct new('selector, 'value) new(selector, value)
+    }
+
+    def ast: line oper: oper arg: arg to: receiver (AST Self new: line) {
+      message = ast: line send: oper arg: arg
+      ast: line send: message to: receiver
+    }
+
+    def ast: line send: message to: receiver (AST Self new: line) ruby: ruby (nil) {
+      args = ruby if_do: {
+        unless: receiver do: {
+          receiver = AST Self new: line
+        }
+        ruby
+      } else: {
+        AST MessageArgs new: line args: []
+      }
+      name = message
+      if: (message kind_of?(String)) then: {
+        name = AST Identifier from: message line: line
+      }
+      if: (message kind_of?(Array)) then: {
+        name = message map: |m| { m selector() string } . join
+        name = AST Identifier new: line string: name
+        args = message map: |m| { m value() }
+        args = AST MessageArgs new: line args: args
+      }
+      AST MessageSend new: line message: name to: receiver args: args
+    }
+
+    def method_name: margs {
+      margs map: |a| { a selector() string } . join("")
+    }
+
+    def method: margs delegators: block {
+      idx = margs index() |m| { m default() != nil }
+      if: idx then: {
+        line = margs first selector() line
+        target = method_name: margs
+        (margs size - idx) times: |pos| {
+          required = margs from: 0 to: (idx + pos - 1)
+          default = margs from: (idx + pos) to: -1
+          params = required map: |r| { r variable() } . + $ default map: |d| { d default() }
+
+          forward = AST MessageSend new: line \
+                                    message: (AST Identifier from: target line: line) \
+                                    to:  (AST Self new: line)                     \
+                                    args:(AST MessageArgs new: line args: params)
+
+          doc = AST StringLiteral new: line value: ("Forward to message " ++ target)
+          body = AST ExpressionList new: line  list: [doc, forward]
+          block call: [[required, body]]
+        }
+      }
+    }
+
+    def ast: line oper: op arg: arg body: body access: access ('public) owner: owner (nil) {
+      margs = [ast: line param: op var: arg]
+      ast: line method: margs body: body access: access owner: owner
+    }
+
+    def ast: line method: margs body: body access: access ('public) owner: owner (nil) {
+      if: (margs is_a?(AST Identifier)) then: {
+        args = AST MethodArgs new: line args: []
+        if: owner then: {
+          AST SingletonMethodDef new: line name: margs args: args \
+                                 body: body access: access owner: owner
+        } else: {
+          AST MethodDef new: line name: margs args: args body: body access: access
+        }
+      } else: {
+        name = method_name: margs
+        name = AST Identifier new: line string: name
+        args = margs map() |m| { m variable() string }
+        args = AST MethodArgs new: line args: args
+        if: owner then: {
+          AST SingletonMethodDef new: line name: name args: args \
+                                 body: body access: access owner: owner
+        } else: {
+          AST MethodDef new: line name: name args: args body: body access: access
+        }
+      }
+    }
+
+    def ast: line method: margs expand: body access: access ('public) owner: owner (nil) {
+      defs = []
+      method: margs delegators: |sel fwd| {
+        defs << $ ast: line method: sel body: fwd access: access owner: owner
+      }
+      defs << $ ast: line method: margs body: body access: access owner: owner
+      AST ExpressionList new: line list: defs
+    }
+
+    def ast: line block: body {
+      args = AST BlockArgs new: line
+      AST BlockLiteral new: line args: args body: body
+    }
+
+    def ast: line partial_block: body {
+      gen_blockarg = AST Identifier generate: line
+      args = AST BlockArgs new: line args: [gen_blockarg]
+      AST BlockLiteral new: line args: args body: body partial: true
+    }
+
+    def ast: line block: body args: args {
+      args = AST BlockArgs new: line args: args
+      AST BlockLiteral new: line args: args body: body
+    }
+
+    def ast: line require_: file {
+      AST Require new: line file: file
+    }
+
+    def ast: line class: name parent: parent body: body {
+      AST ClassDef new: line name: name parent: parent body: body
+    }
+
+    def ast: line match_expr: expr body: match_body {
+      AST Match new: line expr: expr body: match_body
+    }
+
+    def ast: line match_clause: expr body: body args: match_args ([]) {
+      AST MatchClause new: line expr: expr body: body args: match_args
+    }
+
+    def ast: line ex_handler: expr_list cond: cond (AST Identifier from: "Object" line: line) var: var (nil) {
+      AST ExceptionHandler new: line condition: cond var: var body: expr_list
+    }
+
+    def ast: line try_block: body ex_handlers: handlers finally_block: finaly (AST NilLiteral new: line) {
+      AST TryCatch new: line body: body handlers: handlers ensure: finaly
+    }
+
+    def ast: line ruby_send: text {
+      name = text from: 0 to: -2  # remove the open left paren
+      ast: line identifier: name
+    }
+
+    def ast: line ruby_args: args block: block (nil) {
+      { args = [] } unless: args
+      AST RubyArgs new: line args: args block: block
+    }
+
+    def ast: line parse_error: text {
+      ("Parse error near `" ++ text ++ "' at line " ++ line ++ " at " ++ @filename) . raise!
+    }
+
+    def ast: line file_error: text {
+      ("File error `" ++ text ++ "' while trying to parse " ++ @filename) . raise!
+    }
+
+  }
+}
+

data/lib/rbx.fy

@@ -0,0 +1,37 @@
+# rbx.fy
+# This file loads all the rubinius-specific class & method definition
+# files from the lib/rbx/ directory in the correct order.
+
+# NOTE:
+# Don't change the order in here, unless you know what you're doing.
+
+require: "rbx/documentation"
+require: "rbx/object"
+require: "rbx/class"
+require: "rbx/console"
+require: "rbx/array"
+require: "rbx/hash"
+require: "rbx/false_class"
+require: "rbx/string"
+require: "rbx/symbol"
+require: "rbx/integer"
+require: "rbx/fixnum"
+require: "rbx/float"
+require: "rbx/bignum"
+require: "rbx/block"
+require: "rbx/tuple"
+require: "rbx/range"
+require: "rbx/system"
+require: "rbx/exception"
+require: "rbx/io"
+require: "rbx/file"
+require: "rbx/tcp_server"
+require: "rbx/tcp_socket"
+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"

data/lib/rbx/array.fy

@@ -0,0 +1,237 @@
+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
+
+  def Array new: size with: default {
+    "Creates a new Array with a given size and default-value."
+
+    Array new(size, default)
+  }
+
+  def Array new: size {
+    "Creates a new Array with a given size (default value is nil)."
+
+    Array new: size with: nil
+  }
+
+  def append: arr {
+    "Appends another Array onto this one."
+
+    arr each: |x| {
+      self << x
+    }
+  }
+
+  def includes?: obj {
+    "Indicates, if an Array includes a given value."
+
+    self include?(obj)
+  }
+
+  def clone {
+    "Clones (shallow copy) the Array."
+    new = []
+    each: |x| {
+      new << x
+    }
+    new
+  }
+
+  def each: block {
+    "Calls a given Block with each element in the Array."
+
+    val = nil
+    each() |x| { val = block call: [x] }
+    val
+  }
+
+  def remove_at: index {
+    """Removes an element at a given index.
+     If given an Array of indices, removes all the elements with these indices.
+     Returns the deleted object if an index was given, the last deleted object for an Array given."""
+
+    if: (index is_a?: Fixnum) then: {
+      deleted = self at: index
+      delete_at(index)
+      return deleted
+    } else: {
+      if: (index is_a?: Array) then: {
+        count = 0
+        deleted_values = []
+        index each: |idx| {
+          deleted_values << (self at: (idx - count))
+          delete_at(idx - count)
+          count = count + 1
+        }
+        return deleted_values
+      }
+    }
+    nil
+  }
+
+  def at: idx {
+    "Returns the element in the Array at a given index."
+
+    ruby: '[] args: [idx]
+  }
+
+  def at: idx put: obj {
+    "Inserts a given object at a given index (position) in the Array."
+
+    ruby: '[]= args: [idx, obj]
+  }
+
+  def first {
+    "Returns the first element in the Array."
+    at: 0
+  }
+
+  def second {
+    "Returns the second element in the Array"
+    at: 1
+  }
+
+  def third {
+    "Returns the third element in the Array"
+    at: 2
+  }
+
+  def fourth {
+    "Returns the fourth element in the Array"
+    at: 3
+  }
+
+  def each_with_index: block {
+    "Iterate over all elements in Array. Calls a given Block with each element and its index."
+
+    i = 0
+    each: |x| {
+      block call: [x, i]
+      i = i + 1
+    }
+  }
+
+  def index: item {
+    "Returns the index of an item (or nil, if it isn't in the Array)."
+    index(item)
+  }
+
+  def indices_of: item {
+    "Returns an Array of all indices of this item. Empty Array if item does not occur."
+
+    tmp = []
+    each_with_index: |obj, idx| {
+      if: (item == obj) then: {
+        tmp << idx
+      }
+    }
+    tmp
+  }
+
+  def from: from to: to {
+    "Returns sub-array starting at from: and going to to:"
+
+    if: (from < 0) then: {
+      from = self size + from
+    }
+    if: (to < 0) then: {
+      to = self size + to
+    }
+    subarr = []
+    from upto: to do_each: |i| {
+      subarr << (self at: i)
+    }
+    subarr
+  }
+
+  def last: count {
+    "Returns new Array with last n elements specified."
+    last(count)
+  }
+
+  def any?: block {
+    "Takes condition-block and returns true if any element meets it."
+    any?(&block)
+  }
+
+  def all?: block {
+    "Takes condition-block and returns true if all elements meet it."
+    all?(&block)
+  }
+
+  def select: block {
+    """
+    Returns a new Array with all the elements in self that yield a
+    true-ish value when called with the given Block.
+    """
+
+    tmp = []
+    each: |x| {
+      if: (block call: [x]) then: {
+        tmp << x
+      }
+    }
+    return tmp
+  }
+
+  def select_with_index: block {
+    """
+    Same as select, just gets also called with an additional argument
+    for each element's index value.
+    """
+
+    tmp = []
+    each_with_index: |obj idx| {
+      if: (block call: [obj, idx]) then: {
+        tmp << [obj, idx]
+      }
+    }
+    tmp
+  }
+
+  def reject: block {
+    """
+    Returns a new Array with all the elements which yield nil or false
+    when called with the given Block.
+    """
+
+    reject(&block)
+  }
+
+  def reject!: block {
+    "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(join_str)
+  }
+
+  def sum {
+    """
+    Calculates the sum of all the elements in the Enumerable
+    (assuming them to be Numbers (implementing '+' & '*')).
+    """
+
+    reduce: |x y| { x + y } init_val: 0
+  }
+
+  def product {
+    """Calculates the product of all the elements in the Enumerable
+      (assuming them to be Numbers (implementing '+' & '*'))."""
+
+    reduce: |x y| { x * y } init_val: 1
+  }
+}