fancy 0.3.0

data/lib/rbx/bignum.fy

@@ -0,0 +1,23 @@
+class Bignum {
+  include: Number
+
+  ruby_alias: '==
+  ruby_alias: '-
+  ruby_alias: '+
+  ruby_alias: '*
+  ruby_alias: '/
+  ruby_alias: '<
+  ruby_alias: '>
+  ruby_alias: '<=
+  ruby_alias: '>=
+  ruby_alias: '===
+  ruby_alias: 'chr
+  ruby_alias: 'to_i
+  ruby_alias: '**
+  ruby_alias: '&
+
+  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
+  alias_method: 'div: for: 'div
+}

data/lib/rbx/block.fy

@@ -0,0 +1,9 @@
+# Block = BlockEnvironment
+
+class Block {
+  def argcount {
+    "Returns the amount of arguments (arity) a Block takes."
+
+    arity()
+  }
+}

data/lib/rbx/class.fy

@@ -0,0 +1,129 @@
+class Class {
+  ruby_alias: 'superclass
+  ruby_alias: '===
+  ruby_alias: 'ancestors
+
+  def new {
+    """
+    @return A new @Class@ subclassed from @Object@.
+
+    Creates a new @Class@ instance by subclassing @Object@.
+    """
+
+    obj = self allocate()
+    obj initialize
+    obj
+  }
+
+  # calls initialize:, if defined
+  def new: superclass {
+    """
+    @superclass The superclass to inherit from.
+    @return A new @Class@ inherited from @superclass.
+
+    Creates a new @Class@ instance by subclassing @superclass.
+    """
+
+    obj = self allocate()
+    obj initialize: superclass
+    obj
+  }
+
+  def Class superclass: superclass body: body_block {
+    """
+    @superclass The superclass to inherit from.
+    @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.
+    """
+
+    new(superclass, &body_block)
+  }
+
+  def define_method: name with: block {
+    """
+    @name Name of the method to be defined.
+    @block A @Block@ that is used as the method's body.
+
+    Defines an instance method on a @Class@ with a given name and
+    body.
+    """
+
+    define_method(message_name: name, &block)
+  }
+
+  def undefine_method: name {
+    """
+    @name Name of the method to undefine (remove) from a @Class@.
+
+    Undefines an instance method on a Class with a given name.
+    """
+
+    remove_method(message_name: name)
+  }
+
+  def define_class_method: name with: block {
+    """
+    @name Name of the class method to be defined.
+    @block A @Block@ to be used as the class methods body.
+
+    Defines a class method on a @Class@ (a singleton method) with a
+    given name and body.
+    """
+
+    define_singleton_method: name with: block
+  }
+
+  def undefine_class_method: name {
+    """
+    @name Name of the class method to undefine (remove).
+
+    Undefines a class method on a @Class@ with a given name.
+    """
+
+    undefine_singleton_method: name
+  }
+
+  def subclass: body_block {
+    """
+    @body_block A @Block@ that gets used as the body of the @Class@.
+    @return A new @Class@ inherited from @self.
+
+    Creates a new @Class@ with @self as superclass and the given body.
+    """
+
+    Class superclass: self body: body_block
+  }
+
+  def nested_classes {
+    """
+    @return @Array@ of all nested classes for @self.
+
+    Returns all the nested classes within a @Class@ as an @Array@.
+    """
+
+    "Not Yet Implemented" raise!
+  }
+
+  def instance_method: name {
+    """
+    @name Name of the instance method to return.
+    @return The instance @Method@ with the given @name or @nil.
+
+    Returns an instance method for a @Class@ with a given name.
+    """
+
+    self instance_method(message_name: name)
+  }
+
+  def alias_method_rbx: new_method_name for: old_method_name {
+    """
+    Rbx specific version of alias_method:for: due to bootstrap order
+    reasons. Should not be used directly.
+    """
+
+    alias_method(message_name: new_method_name, message_name: old_method_name)
+  }
+}

data/lib/rbx/code_loader.fy

@@ -0,0 +1,192 @@
+class Fancy {
+  class CodeLoader {
+    """
+    Fancy CodeLoader.
+
+    Is used to load Fancy source (.fy) and compiled (.fyc) files into
+    the runtime.
+    """
+
+    SOURCE_FILE_EXTENSION = "fy"
+    COMPILED_FILE_EXTENSION = "fyc"
+
+    @@load_path = []
+    @@loaded = <[]>
+    @@compiled = <[]>
+    @@file_stack = []
+    @@current_dir = []
+
+    def self file_stack {
+      @@file_stack
+    }
+
+    def self loaded {
+      @@loaded
+    }
+
+    def self load_path {
+      @@load_path
+    }
+
+    def self push_loadpath: path {
+      """
+      @path The path to add to the @LOADPATH
+
+      Adds a given path to Fancy's @LOADPATH.
+      """
+      { @@load_path << path } unless: $ @@load_path includes?: path
+    }
+
+    # Throws an exception for a given filename that wasn't found and
+    # thus could not be loaded.
+    def self load_error: filename {
+      "LoadError: Can't find file: " ++ filename raise!
+    }
+
+    # Returns the name of a file or nil, if it doesn't exist.
+    # Might append a ".fy" extension, if it's missing for the given
+    # filename.
+    def self find_file: filename {
+      filename_with_ext = filename + "." + SOURCE_FILE_EXTENSION
+      if: ({File exists?(filename) not} || {File directory?(filename)}) then: {
+        { return filename_with_ext } if: $ File exists?(filename_with_ext)
+      } else: {
+        return filename
+      }
+      nil
+    }
+
+    # Finds a file in a given path and returns the filename including
+    # the path.
+    def self find_file: file in_path: path {
+      find_file: $ path + "/" + file
+    }
+
+
+    # Tries to find a file with a given name in the LOADPATH array
+    # (all paths that have been seen while loading other files so
+    # far), starting with the @current_dir (the directory, the current
+    # running fancy source file is in).
+    def self filename_for: filename {
+      if: (find_file: filename) then: |f| {
+        return f
+      } else: {
+        if: (@@current_dir last) then: {
+          if: (find_file: filename in_path: (@@current_dir last)) then: |f| {
+            return f
+          }
+        }
+        @@load_path each: |p| {
+          try {
+            if: (find_file: filename in_path: p) then: |f| {
+              return f
+            }
+          } catch {
+          }
+        }
+      }
+      load_error: filename
+    }
+
+    # Returns the source filename for a given filename.
+    # E.g. "foo.fyc" => "foo.fy"
+    def self source_filename_for: file {
+      match file -> {
+        case /.*\.compiled\.fyc$/ -> file from: 0 to: -14
+        case /.*\.fyc$/ -> file from: 0 to: -2
+        case /\.fy$/ -> file
+        case _ -> file
+      }
+    }
+
+    # Returns the compiled filename for a given filename.
+    # E.g. "foo.fy" => "foo.fyc", "foo" => "foo.compiled.rbc"
+    def self compiled_filename_for: file {
+      match file -> {
+        case /\.fyc$/ -> file
+        case /\.fy$/ -> file + "c"
+        case _ -> file + ".compiled.fyc"
+      }
+    }
+
+    # Optionally compiles a file, if not done yet and returns the
+    # compiled file's name.
+    def self optionally_compile_file: f {
+      source_filename = source_filename_for: f
+      filename = filename_for: source_filename
+      compiled_file = compiled_filename_for: filename
+      unless: (@@compiled[filename]) do: {
+        if: ({File exists?(compiled_file) not} || \
+             {File stat(compiled_file) mtime() <((File stat(filename) mtime()))}) then: {
+          # Rubinius::Compiler.compile_fancy_file filename, nil, 1, false
+          Compiler compile_file: filename to: compiled_file
+        } else: {
+          @@compiled at: filename put: true
+        }
+      }
+      compiled_file
+    }
+
+
+    # Loads a compiled fancy bytecode file.
+    # If +find_file+ is set to false, it will just use the given
+    # filename without looking up the file in the LOADPATH.
+    def self load_compiled_file: source_file find_file: find_file (true) {
+      compiled_file = source_file
+
+      if: find_file then: {
+        source_file = filename_for: source_file
+
+        dir = File expand_path(File dirname(source_file), ".")
+        source_file = File expand_path(File basename(source_file), dir)
+
+        compiled_file = compiled_filename_for: source_file
+      }
+
+      compiled_file = optionally_compile_file: compiled_file
+
+      unless: (@@loaded[compiled_file]) do: {
+        unless: (File exists?(compiled_file)) do: {
+          load_error: compiled_file
+        }
+
+        dirname = File dirname(compiled_file)
+        push_loadpath: dirname
+        @@current_dir push(dirname)
+        @@loaded at: compiled_file put: true
+
+        cl = Rubinius::CodeLoader new(compiled_file)
+        cm = cl load_compiled_file(compiled_file, 0)
+
+        script = cm create_script(false)
+        script file_path=(source_file)
+
+
+        try {
+          @@file_stack push(source_file)
+          MAIN __send__('__script__)
+        } finally {
+          @@current_dir pop()
+          @@file_stack pop()
+        }
+      }
+    }
+
+    def self current_file: compiled_from {
+      @@file_stack last
+    }
+
+    def self file_not_found: file {
+      "File not found: " ++ file . raise!
+    }
+
+    def self fancy_require: file {
+       load_compiled_file: file find_file: true
+    }
+
+    self metaclass send('alias_method, "require:", "fancy_require:")
+    self metaclass send('alias_method, "load:", "load_compiled_file:")
+    self metaclass send('alias_method, "load_compiled_file", "load_compiled_file:")
+    self metaclass send('alias_method, "push_loadpath", "push_loadpath:")
+  }
+}

data/lib/rbx/console.fy

@@ -0,0 +1,63 @@
+class Console {
+  "Console class. Used for @STDIO."
+
+  def Console newline {
+    "Prints a newline to @STDOUT."
+
+    STDOUT puts()
+  }
+
+  def Console print: obj {
+    """
+    @obj Object to be printed on @STDOUT.
+
+    Prints a given object on @STDOUT.
+    """
+
+    STDOUT print(obj)
+  }
+
+  def Console println: obj {
+    """
+    @obj Object to be printed on @STDOUT, followed by a newline.
+
+    Prints a given object on @STDOUT, followed by a newline.
+    """
+
+    STDOUT puts(obj)
+  }
+
+  def Console readln: message {
+
+    """
+    @message A @String@ that should be printed to @STDOUT before reading from @STDIN.
+    @return Line (@String@) read from @STDIN.
+
+    Prints a given message to @STDOUT, followed by reading a line from
+    @STDIN.
+    """
+
+    Console print: message
+    if: (STDIN eof?) then: {
+      nil
+    } else: {
+      STDIN gets() chomp
+    }
+  }
+
+  def Console readln {
+    """
+    @return Line (@String@) read from @STDIN.
+
+    Reads a line from @STDIN and returns it as a @String@.
+    """
+
+    STDIN gets() chomp
+  }
+
+  def Console clear {
+    "Clears the @Console@."
+
+    STDOUT print("\033[H\033[2J")
+  }
+}

data/lib/rbx/directory.fy

@@ -0,0 +1,46 @@
+class Directory {
+  def self create: dirname {
+    """
+    @dirname Path of @Directory@ to create.
+
+    Creates a new @Directory@ on the filesystem, possibly throwing
+    IOError Exceptions that might occur.
+    """
+
+    try {
+      Dir mkdir(dirname)
+    } catch Errno::EEXIST => e {
+      IOError new: (e message) . raise!
+    }
+  }
+
+  def self create!: dirname {
+    """
+    @dirname Path of @Directory@ to create.
+
+    Creates a new @Directory@ on the filesystem, ignoring any
+    Exceptions that might occur.
+    Basically works like running `mkdir -p` on the shell.
+    """
+
+    try {
+      create: dirname
+    } catch IOError {
+    }
+  }
+
+
+  def self delete: dirname {
+    """
+    @dirname Path to @Directory@ to delete.
+
+    Deletes a directory with a given name, if it's empty.
+    """
+
+    try {
+      Dir delete(dirname)
+    } catch Exception => e {
+      IOError new: (e message) . raise!
+    }
+  }
+}