fancy 0.3.0

data/lib/compiler/command.fy

@@ -0,0 +1,51 @@
+require("fileutils")
+
+class Fancy {
+  class Compiler Command {
+
+    def self option: argv flag: name {
+      argv delete(name)
+    }
+
+    def self option: argv value: name {
+      idx = argv index(name)
+      if: idx then: {
+        value = argv delete_at(idx + 1)
+        argv delete_at(idx)
+        value
+      } else: {
+        nil
+      }
+    }
+
+    def self run: argv {
+      batch = option: argv flag: "--batch"
+      print = option: argv flag: "-B"
+      src_path = option: argv value: "--source-path"
+      out_path = option: argv value: "--output-path"
+      argv each() |f| {
+        o = nil
+        if: (out_path && src_path) then: {
+          o = f sub(src_path, out_path) + "c"
+        }
+        compile: f to: o info: batch print: print
+      }
+      if: batch then: {
+        size = argv size()
+        files = "file"
+        { files = files + "s" } if: (size > 1)
+        "Compiled " ++ (argv size()) ++ " " ++ files ++ "." . println
+      }
+    }
+
+    def self compile: file to: to (nil) info: info (false) print: print (false) {
+      if: info then: {
+        "Compiling " ++ file println
+      }
+      if: to then: {
+        FileUtils mkdir_p(File dirname(to))
+      }
+      Compiler compile_file: file to: to line: 1 print: print
+    }
+  }
+}

data/lib/compiler/compiler.fy

@@ -0,0 +1,73 @@
+class Fancy {
+
+  class Compiler : Rubinius Compiler {
+
+    read_write_slots: ['parser, 'generator, 'packager, 'writer]
+
+    def self compiled_name: file {
+     """
+       Returns a the compiled filename for @file
+
+       If file ends with .fy extention the will return with .fyc extension
+       Otherwise it will append .compiled.fyc to the filename.
+     """
+
+      if: (file suffix?(".fy")) then: {
+        file + "c"
+      } else: {
+        file + ".compiled.fyc"
+      }
+    }
+
+    def self from: first_stage to: last_stage {
+      "Creates a new compiler from @first_stage to @last_stage"
+
+      new(first_stage, last_stage)
+    }
+
+    def self compile_code: code vars: scope file: file line: line print: print (false) {
+      compiler = from: 'fancy_code to: 'compiled_method
+      parser = compiler parser
+      parser root: Rubinius AST EvalExpression
+      parser input: code file: file line: line
+      if: print then: {
+        parser print: true
+        printer = compiler packager print()
+        printer bytecode=(true)
+      }
+      compiler generator variable_scope: scope
+      result = nil
+      try {
+        result = compiler run()
+      } catch Exception => e {
+        compiler_error("Error trying to compile " ++ file, e)
+      }
+      result
+    }
+
+    def self compile_file: file to: output (nil) line: line (1) print: print (false) {
+      compiler = from: 'fancy_file to: 'compiled_file
+      parser = compiler parser
+      parser root: Rubinius AST Script
+      parser input: file line: line
+      if: print then: {
+        parser print: true
+        printer = compiler packager print()
+        printer bytecode=(true)
+      }
+      writer = compiler writer
+      if: output then: {
+        writer name=(output)
+      } else: {
+        writer name=(compiled_name: file)
+      }
+      try {
+        compiler run()
+      } catch Exception => e {
+        compiler_error("Error trying to compile " ++ file, e)
+      }
+    }
+
+  }
+
+}

data/lib/compiler/stages.fy

@@ -0,0 +1,81 @@
+class Fancy Compiler Stages {
+
+  class Stage : Rubinius Compiler Stage {
+
+    initialize = |compiler, last| {
+      sup = Rubinius Compiler Stage instance_method('initialize)
+      sup bind(self) call(compiler, last)
+      initialize: compiler last: last
+    }
+    define_method('initialize, &initialize)
+
+    def self stage: name next: next (nil) {
+      stage(name)
+      next_stage(next)
+    }
+
+    run = { self run; run_next() }
+    define_method('run, &run)
+
+  }
+
+  class FancyGenerator : Stage {
+
+    stage: 'fancy_bytecode next: Rubinius Compiler Encoder
+
+    read_write_slots: ['variable_scope]
+
+    def initialize: compiler last: last {
+      @variable_scope = nil
+      compiler generator: self
+    }
+
+    def run {
+      @output = Rubinius Generator new()
+      @input variable_scope=(@variable_scope)
+      @input bytecode(@output)
+      @output close()
+    }
+
+  }
+
+  class FancyCodeParser : Stage {
+    stage: 'fancy_code next: FancyGenerator
+    read_write_slots: ['root, 'print]
+
+    def initialize: compiler last: last {
+      compiler parser: self
+    }
+
+    def input: @code file: @filename line: @line (1) {}
+
+    def run {
+      ast = Fancy Parser parse_code: @code file: @filename line: @line
+      # if: @print then: { ast inspect println }
+      @output = @root new(ast)
+      @output file=(@filename)
+    }
+  }
+
+  class FancyFileParser : Stage {
+
+    stage: 'fancy_file next: FancyGenerator
+    read_write_slots: ['root, 'print]
+
+    def initialize: compiler last: last {
+      compiler parser: self
+    }
+
+    def input: @filename line: @line (1) {}
+
+    def run {
+      ast = Fancy Parser parse_file: @filename line: @line
+      # if: @print then: { ast inspect println }
+      @output = @root new(ast)
+      @output file=(@filename)
+    }
+
+  }
+
+}
+

data/lib/directory.fy

@@ -0,0 +1,17 @@
+class Directory {
+  """
+  Instances of @Directory@ represent directories in the filesystem of
+  the operating system, in which Fancy is being run.
+  """
+
+  def self exists?: dirname {
+    """
+    @dirname Path of @Directory@ to check for existance.
+    @@return @true, if @Directory@ exists, @false otherwise.
+
+    Indicates, if a Directory exists with a given pathname.
+    """
+
+    (File exists?: dirname) and: (File directory?: dirname)
+  }
+}

data/lib/documentation.fy

@@ -0,0 +1,115 @@
+class Fancy Documentation {
+
+  """
+   A Fancy Documentation object is a holder for docstrings and specs.
+   Keeps a registry of documentation for anything Fancy.
+
+   Provides methods for searching and formatting objects' docstrings
+   this can be be handy for users of interactive Fancy REPL,
+   document generators, instrospection toos, IDEs, anything!.
+
+   This object can be converted to just anything by using its format:
+   method. formatters can be registered with Fancy Documentation formatter:is:
+
+   By default two formatters are defined:
+
+        'fancy    => Returns the Fancy::Documentation object
+        'string   => Returns the docs string representation
+  """
+  read_write_slots: ['object, 'docs, 'specs]
+
+  instance_method: 'docs . executable() . documentation: """
+     An array of docstrings for the object beind documented.
+
+     We have an array of docstrings because in Fancy, some
+     things like classes can be re-openned and the user may
+     specify new documentation for it each time. Thus we dont
+     want to loose the previous documentation but rather build
+     upon it. That is, fancy supports incremental documentation.
+  """
+
+  instance_method: 'specs . documentation: """
+     An array of associated Fancy specs for the object
+     being documented.
+
+     Its a lot better to keep the associated specs in
+     Fancy Documentation objects instead of just having them
+     in method instances. This allows us to associate any object
+     with an spec example.
+
+     This way you can have a single Fancy spec example that
+     is related to many objects (methods, constants, classes)
+     that are being specified. Later in documentation, we can
+     provide links to all specs where an object is being exercised.
+  """
+
+  def to_s { @docs join: "\n" }
+
+  def format: format {
+    """
+      If format is specified, the documentation string will be
+      converted using the corresponding formatter. This allows
+      you to extend Fancy documentation system, and produce
+      html documents, man pages, or anything you can imagine.
+    """
+    formatter = Fancy Documentation formatter: format
+    { "No such documentation format: " ++ format . raise! } unless: formatter
+    formatter call: [self]
+  }
+
+  def self for: obj append: docstring {
+    """
+      Append docstring to the documentation for obj.
+      If obj has no documentation, one is created for it.
+    """
+    doc = self for: obj
+    doc if_do: {
+      doc docs << docstring
+    } else: {
+      doc  = self for: obj is: docstring
+    }
+    doc
+  }
+
+  def self formatter: name {
+    "Obtain a formatter by the given name. Returns a callable object"
+    self formatters at: name
+  }
+
+  def self formatter: name is: callable {
+    "Register a callable object as formatter under name."
+    self formatters at: name put: callable
+  }
+
+  def self formatters {
+    "Obtain the hash of known documentation formatters."
+    unless: @formatters do: { @formatters = <[]> }
+    @formatters
+  }
+
+  self formatter: 'fancy  is: |doc| { doc }
+  self formatter: 'string is: |doc| { doc to_s }
+
+  # TODO: implement. Plain is just like string but including spec names.
+  self formatter: 'plain  is: |doc| { doc to_s }
+
+}
+
+class Fancy Documentation RDiscount {
+
+  "A documentation formatter using ruby's RDiscount markdown"
+  Fancy Documentation formatter: 'rdiscount is: |d| { rdiscount: d }
+
+  # Register as default markdown formatter.
+  Fancy Documentation formatter: 'markdown is: |d| { rdiscount: d }
+
+  def self rdiscount: doc {
+    "Format string as HTML using RDiscount ruby gem."
+    require("rubygems")
+    require("rdiscount")
+    RDiscount.new(doc to_s).to_html()
+  }
+
+}
+
+

data/lib/enumerable.fy

@@ -0,0 +1,269 @@
+class FancyEnumerable {
+  """
+  Mixin-Class with useful methods for collections that implement an @each:@ method.
+  """
+
+  def includes?: item {
+    """
+    @item Item to check if it's included in @self.
+    @return @true, if @item in @self, otherwise @false.
+
+    Indicates, if a collection includes a given element.
+    """
+    any?: |x| { item == x }
+  }
+
+  def each: each_block in_between: between_block {
+    """
+    Similar to @each:@ but calls an additional @Block@ between
+    calling the first @Block@ for each element in self.
+    """
+
+    count = 0
+    size = self size
+    each: |x| {
+      each_block call: [x]
+      unless: (count == (size - 1)) do: {
+        between_block call
+      }
+      count = count + 1
+    }
+  }
+
+  def any?: condition {
+    """
+    @condition @Block@ (or @Callable) that is used to check if any element in @self yields true for it.
+    @return @true, if @condition yields @true for any element, @false otherwise.
+
+    Indicates, if any element meets the condition.
+    """
+
+    each: |x| {
+      if: (condition call: [x]) then: {
+        return true
+      }
+    }
+    nil
+  }
+
+  def all?: condition {
+    """
+    Similar to @FancyEnumerable#any?:@ just checking for all elements.
+    Indicates, if all elements meet the condition.
+    """
+
+    each: |x| {
+      unless: (condition call: [x]) do: {
+        return false
+      }
+    }
+    true
+  }
+
+  def find: item {
+    "Returns @nil, if the given object isn't found, or the object, if it is found."
+
+    if: (item is_a?: Block) then: {
+      find_by: item
+    } else: {
+      each: |x| {
+        if: (item == x) then: {
+          return x
+        }
+      }
+      nil
+    }
+  }
+
+  def find_by: block {
+    """
+    Similar to @find:@ but takes a block that is called for each element to find it.
+    """
+
+    each: |x| {
+      block call: [x] . if_do: |item| {
+        return item
+      }
+    }
+    nil
+  }
+
+  def map: block {
+    "Returns a new @Array@ with the results of calling a given block for every element"
+
+    coll = []
+    each: |x| {
+      coll << (block call: [x])
+    }
+    coll
+  }
+
+  def select: condition {
+    "Returns a new @Array@ with all elements that meet the given condition block."
+
+    coll = []
+    each: |x| {
+      { coll << x } if: $ condition call: [x]
+    }
+    coll
+  }
+
+  def reject: condition {
+    "Returns a new @Array@ with all elements that don't meet the given condition block."
+
+    coll = []
+    each: |x| {
+      { coll << x } unless: $ condition call: [x]
+    }
+    coll
+  }
+
+  def take_while: condition {
+    "Returns a new @Array@ by taking elements from the beginning as long as they meet the given condition block."
+    coll = []
+    each: |x| {
+      if: (condition call: [x]) then: {
+        coll << x
+      } else: {
+        return coll
+      }
+    }
+    coll
+  }
+
+  def drop_while: condition {
+    "Returns a new @Array@ by skipping elements from the beginning as long as they meet the given condition block."
+
+    coll = []
+    drop = nil
+    first_check = true
+    each: |x| {
+      if: (drop or: first_check) then: {
+        drop = condition call: [x]
+        first_check = nil
+        # check, if we actually have to insert his one:
+        unless: drop do: {
+          coll << x
+        }
+      } else: {
+        coll << x
+      }
+    }
+    coll
+  }
+
+  def take: amount {
+    i = 0
+    self take_while: {
+      i = i + 1
+      i <= amount
+    }
+  }
+
+  def drop: amount {
+    i = 0
+    self drop_while: {
+      i = i + 1
+      i <= amount
+    }
+  }
+
+  def reduce: block init_val: init_val {
+    "Calculates a value based on a given block to be called on an accumulator value and an initial value."
+
+    acc = init_val
+    each: |x| {
+      acc = (block call: [acc, x])
+    }
+    acc
+  }
+
+  def uniq {
+    "Returns a new Array with all unique values (double entries are skipped)."
+
+    uniq_vals = []
+    each: |x| {
+      unless: (uniq_vals includes?: x) do: {
+        uniq_vals << x
+      }
+    }
+    uniq_vals
+  }
+
+  def size {
+    "Returns the size of an Enumerable."
+
+    i = 0
+    each: |x| {
+      i = i + 1
+    }
+    i
+  }
+
+  def empty? {
+    "Indicates, if the Enumerable is empty (has no elements)."
+    self size == 0
+  }
+
+  def first {
+    self each: |x| {
+      return x
+    }
+  }
+
+  def last {
+    "Returns the last element in an Enumerable."
+
+    item = nil
+    each: |x| {
+      item = x
+    }
+    item
+  }
+
+  def compact {
+    "Returns a new @Array@ with all values removed that are @nil ( return @true on @nil? )."
+
+    reject: |x| { x nil? }
+  }
+
+  def superior_by: comparison_block {
+    "Returns the superiour element in the @Enumerable that has met the given comparison block with all other elements."
+
+    retval = self first
+    each: |x| {
+      if: (comparison_block call: [x, retval]) then: {
+        retval = x
+      }
+    }
+    retval
+  }
+
+  def max {
+    "Returns the maximum value in the Enumerable (via the '>' comparison message)."
+    superior_by: '>
+  }
+
+  def min {
+    "Returns the minimum value in the Enumerable (via the '<' comparison message)."
+    superior_by: '<
+  }
+
+  def partition_by: block {
+    last = block call: [self first]
+    coll = []
+    tmp_coll = []
+    self each: |x| {
+      tmp = block call: [x]
+      if: (tmp != last) then: {
+        coll << tmp_coll
+        tmp_coll = [x]
+      } else: {
+        tmp_coll << x
+      }
+      last = tmp
+    }
+    coll << tmp_coll
+    coll
+  }
+}