fancy 0.3.0

data/lib/fdoc_hook.fy

@@ -0,0 +1,10 @@
+class Fancy FDoc {
+  # A hash to keep all objects to extract documentation from.
+  # Having this hash only for FDoc is fine IMHO. As we dont need
+  # to use ObjectSpace or anything like that. Just to produce docs.
+  @documented_objects = <[]>
+  Fancy Documentation on_documentation_set: |object, documentation| {
+    @documented_objects store(object, documentation)
+  }
+}
+

data/lib/file.fy

@@ -0,0 +1,54 @@
+class File {
+  """
+  Instances of File represent files in the filesystem of the operating
+  system on which Fancy is running.
+  """
+
+  # def self exists?: filename {
+  #   "Indicates, if a File exists with a given filename."
+  #   try {
+  #     f = File open: filename modes: ['read]
+  #     f close
+  #     true
+  #   } catch IOError => e {
+  #     nil
+  #   }
+  # }
+
+  def self read: filename {
+    """
+    Reads all the contens (in ASCII mode) of a given file and returns
+    them as an Array of lines being read.
+    """
+
+    lines = []
+    File open: filename modes: ['read] with: |f| {
+      { f eof? } while_false: {
+        lines << (f readln)
+      }
+    }
+    lines join: "\n"
+  }
+
+  def writeln: x {
+    """
+    Writes a given argument as a String followed by a newline into the
+    File.
+    """
+
+    write: x
+    self newline
+  }
+
+  def print: x {
+    "Same as File#write:."
+
+    write: x
+  }
+
+  def println: x {
+    "Same as File#writeln:."
+
+    writeln: x
+  }
+}

data/lib/hash.fy

@@ -0,0 +1,56 @@
+class Hash {
+  """
+  Class for Hashes (HashMaps / Dictionaries).
+  Maps a key to a value.
+  """
+
+  include: FancyEnumerable
+
+  def [] key {
+    "Returns the value for a given key."
+
+    at: key
+  }
+
+  def each: block {
+    "Calls a given Block with each key and value."
+
+    if: (block argcount == 1) then: {
+      self keys each: |key| {
+        block call: [[key, at: key]]
+      }
+    } else: {
+      self keys each: |key| {
+        block call: [key, at: key]
+      }
+    }
+  }
+
+  def each_key: block {
+    "Calls a given Block with each key."
+
+    self keys each: |key| {
+      block call: [key]
+    }
+  }
+
+  def each_value: block {
+    "Calls a given Block with each value."
+
+    self values each: |val| {
+      block call: [val]
+    }
+  }
+
+  def to_a {
+    "Returns an Array of the key-value pairs in a Hash."
+
+    map: |pair| { pair }
+  }
+
+  def to_s {
+    "Returns a string representation of a Hash."
+
+    self to_a to_s
+  }
+}

data/lib/main.fy

@@ -0,0 +1,80 @@
+# main.fy
+# This file gets run directly from bin/fancy.
+# It loads up all the necessary auto-load files by loading lib/boot.fy
+# and handles any given ARGV options.
+# Finally, if any .fy source filename is passed in via ARGV, it is
+# loaded and executed.
+
+ARGV for_options: ["-v", "--version"] do: {
+  "Fancy " ++ FANCY_VERSION println
+  "(C) 2010, 2011 Christopher Bertels <chris@fancy-lang.org>" println
+  System exit
+}
+
+ARGV for_options: ["--help", "-h"] do: {
+  ["Usage: fancy [option] [programfile] [arguments]",
+   "  --help                  Print this output",
+   "  -h                      Print this output",
+   "  --version               Print Fancy's version number",
+   "  -v                      Print Fancy's version number",
+   "  -I directory            Add directory to Fancy's LOAD_PATH",
+   "  -e 'command'            One line of Fancy code that gets evaluated immediately",
+   "  -c [filenames]          Compile given files to Rubinius bytecode",
+   "  -cv [filenames]         Compile given files to Rubinius bytecode verbosely (outputting the generated bytecode).",
+   "",
+   "Fancy package management:",
+   "  install   [packagename] Install a Fancy package with a given name to $FANCYPACK_DIR",
+   "  uninstall [packagename] Uninstall a Fancy package with a given name from $FANCYPACK_DIR"] println
+  System exit # quit when running --help
+}
+
+ARGV for_option: "-I" do: |path| {
+  Fancy CodeLoader push_loadpath: path
+}
+
+ARGV for_option: "-e" do: |eval_string| {
+  eval_string eval
+  System exit # quit when running with -e
+}
+
+ARGV for_option: "-c" do: {
+  ARGV index: "-c" . if_do: |idx| {
+    ARGV[[idx + 1, -1]] each: |filename| {
+      "Compiling " ++ filename println
+      Fancy Compiler compile_file: filename to: nil line: 1 print: false
+    }
+  }
+  System exit
+}
+
+ARGV for_option: "-cv" do: {
+  ARGV index: "-cv" . if_do: |idx| {
+    ARGV[[idx + 1, -1]] each: |filename| {
+      "Compiling " ++ filename println
+      Fancy Compiler compile_file: filename to: nil line: 1 print: true
+    }
+  }
+  System exit
+}
+
+ARGV for_option: "install" do: |package_name| {
+  Fancy Package install: package_name
+  System exit
+}
+
+ARGV for_option: "uninstall" do: |package_name| {
+  Fancy Package uninstall: package_name
+  System exit
+}
+
+# push package install dir to load_path
+Fancy Package add_to_loadpath
+
+# Load a source file, if any given:
+ARGV first if_do: |file| {
+  Fancy CodeLoader load_compiled_file: file
+}
+
+ARGV empty? if_do: {
+  require: "../bin/ifancy"
+}

data/lib/method.fy

@@ -0,0 +1,22 @@
+class Method {
+  """
+  An instance of Method represents a method on a Class.
+  Every method in Fancy is an instance of the Method class.
+  """
+
+  def tests {
+    """
+    Returns an Array of all the FancySpec SpecTests defined for a
+    Method.
+    """
+
+    @tests if_nil: { @tests = [] }
+    @tests
+  }
+
+  def test: test_block {
+    it = FancySpec new: self
+    test_block call: [it]
+    self tests << it
+  }
+}

data/lib/nil_class.fy

@@ -0,0 +1,56 @@
+class NilClass {
+  "NilClass. The class of the singleton nil value."
+
+  def NilClass new {
+    # always return nil singleton object when trying to create a new
+    # NilClass instance
+    nil
+  }
+
+  def if_true: then_block else: else_block {
+    "Calls else_block."
+    else_block call
+  }
+
+  def if_true: block {
+    "Returns nil."
+    nil
+  }
+
+  def if_false: block {
+    "Calls the block."
+    block call
+  }
+
+  def if_nil: block {
+    "Calls the block."
+    block call
+  }
+
+  def nil? {
+    "Returns true."
+    true
+  }
+
+  def false? {
+    "Returns true."
+    true
+  }
+
+  def true? {
+    "Returns nil."
+    false
+  }
+
+  def to_s {
+    ""
+  }
+
+  def to_a {
+    []
+  }
+
+  def not {
+    true
+  }
+}

data/lib/number.fy

@@ -0,0 +1,87 @@
+class Number {
+  """
+  Number is a mixin-class for all number values (integer & floats for
+  now).
+  """
+
+  def upto: num {
+    i = self
+    arr = []
+    while: { i <= num } do: {
+      arr << i
+      i = i + 1
+    }
+    arr
+  }
+
+  def downto: num {
+    i = self
+    arr = []
+    while: { i >= num } do: {
+      arr << i
+      i = i - 1
+    }
+    arr
+  }
+
+  def squared {
+    "Returns the square of a Number."
+
+    self * self
+  }
+
+  def doubled {
+    "Returns the double value of a Number."
+
+    self + self
+  }
+
+  def abs {
+    "Returns the absolute (positive) value of a Number."
+
+    if: (self < 0) then: {
+      self * -1
+    } else: {
+      self
+    }
+  }
+
+  def negate {
+    "Negates a Number (-1 becomes 1 and vice versa)."
+
+    self * -1
+  }
+
+  def even? {
+    "Indicates, if a Number is even."
+
+    modulo: 2 . == 0
+  }
+
+  def odd? {
+    "Indicates, if a Number is odd."
+
+    self even? not
+  }
+
+  def to_num {
+    self
+  }
+}
+
+class FancyEnumerable {
+  def sum {
+    """Calculates the sum of all the elements in the @Enumerable
+      (assuming them to be @Number@s (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 @Number@s (implementing @+ & @*))."""
+
+    reduce: |x y| { x * y } init_val: 1
+  }
+}
+

data/lib/object.fy

@@ -0,0 +1,170 @@
+class Object {
+  """
+  Root class of Fancy's class hierarchy.
+  All classes inherit from Object.
+  """
+
+  def loop: block {
+    "Infinitely calls the block (loops)."
+    { true } while_true: {
+      block call
+    }
+  }
+
+  def println {
+    "Same as Console println: self. Prints the object on STDOUT, followed by a newline."
+    Console println: $ self to_s
+  }
+
+  def print {
+    "Same as Console print: self. Prints the object on STDOUT."
+    Console print: $ self to_s
+  }
+
+  def != other {
+    "Indicates, if two objects are unequal."
+    self == other not
+  }
+
+  def if_false: block {
+    "Calls the block."
+    nil
+  }
+
+  def if_nil: block {
+    "Returns nil."
+    nil
+  }
+
+  def nil? {
+    "Returns nil."
+    nil
+  }
+
+  def false? {
+    "Returns nil."
+    nil
+  }
+
+  def true? {
+    "Returns nil."
+    nil
+  }
+
+  def if_do: block {
+    "If the object is non-nil, it calls the given block with itself as argument."
+
+    match self -> {
+      case nil -> nil
+      case false -> nil
+      case _ -> block call: [self]
+    }
+  }
+
+  def if_do: then_block else: else_block {
+    """If the object is non-nil, it calls the given then_block with itself as argument.
+       Otherwise it calls the given else_block."""
+
+    match self -> {
+      case nil -> else_block call: [self]
+      case false -> else_block call: [self]
+      case _ -> then_block call: [self]
+    }
+  }
+
+  def or_take: other {
+    "Returns self if it's non-nil, otherwise returns the given object."
+
+    if: (self nil?) then: {
+      other
+    } else: {
+      self
+    }
+  }
+
+  def to_num {
+    0
+  }
+
+  def to_a {
+    [self]
+  }
+
+  def to_i {
+    0
+  }
+
+  def || other {
+    "Same as Object#or:"
+    or: other
+  }
+
+  def && other {
+    "Same as Object#and:"
+    and: other
+  }
+
+  def if: cond then: block {
+    """
+    Same as:
+        cond if_do: block
+    """
+    cond if_do: block
+  }
+
+  def if: cond then: then_block else: else_block {
+    """
+    Same as:
+        cond if_do: then_block else: else_block
+    """
+    cond if_do: then_block else: else_block
+  }
+
+  def while: cond_block do: body_block {
+    """
+    Same as:
+      cond_block while_do: body_block
+    """
+
+    cond_block while_do: body_block
+  }
+
+  def until: cond_block do: body_block {
+    """
+    Same as:
+      cond_block until_do: body_block
+    """
+
+    cond_block until_do: body_block
+  }
+
+  def unless: cond do: block {
+    """
+    Same as:
+      cond if_do: { nil } else: block
+    """
+
+    cond if_do: { nil } else: block
+  }
+
+  def method: method_name {
+    "Returns the method with a given name for self, if defined."
+
+    method(message_name: method_name)
+  }
+
+  def documentation {
+    "Returns the documentation string for an Object."
+    Fancy Documentation for: self . to_s
+  }
+
+  def documentation: str {
+    "Sets the documentation string for an Object."
+    Fancy Documentation for: self is: str
+  }
+
+  def identity {
+    "The identity method simply returns self."
+    self
+  }
+}