fancy 0.3.0

data/lib/eval.fy

@@ -0,0 +1,31 @@
+require: "compiler"
+
+def Fancy eval: code binding: bnd (nil) file: file ("(fancy-eval)") line: line (1) {
+  bnd if_nil: {
+    bnd = Binding setup(Rubinius VariableScope of_sender(),
+                        Rubinius CompiledMethod of_sender(),
+                        Rubinius StaticScope of_sender())
+  }
+
+  # The compiled method
+  cm = Fancy Compiler compile_code: code vars: (bnd variables()) file: file line: line
+  cm scope=(bnd static_scope() dup())
+  cm name=('__fancy_eval__)
+
+  script = Rubinius CompiledMethod Script new(cm, file, true)
+  script eval_binding=(bnd)
+  script eval_source=(code)
+
+  cm scope() script=(script)
+
+  be = Rubinius BlockEnvironment new()
+  be under_context(bnd variables(), cm)
+
+  if: (bnd from_proc?()) then: {
+    be proc_environment=(bnd proc_environment)
+  }
+
+  be from_eval!()
+
+  be call()
+}

data/lib/fancy_spec.fy

@@ -0,0 +1,202 @@
+class FancySpec {
+  """
+  The FancySpec class is used for defining FancySpec testsuites.
+  Have a look at the tests/ directory to see some examples.
+  """
+
+
+  def initialize: @description test_obj: @test_obj (@description) {
+    @spec_tests = []
+  }
+
+  def FancySpec describe: test_obj with: block {
+    spec = FancySpec new: test_obj
+    block call_with_receiver: spec
+    spec run
+  }
+
+  def FancySpec describe: description for: test_obj with: block {
+    spec = FancySpec new: description test_obj: test_obj
+    block call_with_receiver: spec
+    spec run
+  }
+
+  def it: spec_info_string when: spec_block {
+    test = SpecTest new: spec_info_string block: spec_block
+    @spec_tests << test
+  }
+
+  def it: spec_info_string for: method_name when: spec_block {
+    test = SpecTest new: spec_info_string block: spec_block
+    # try {
+    #   @test_obj method: method_name . if_do: |method| {
+    #     method tests << test
+    #   }
+    # } catch MethodNotFoundError => e {
+    #   # ignore errors
+    # }
+    @spec_tests << test
+  }
+
+  def run {
+    "Running tests for: " ++ @description ++ ": " print
+    @spec_tests each: |test| {
+      test run: @test_obj
+    }
+#    Console newline Console newline
+    # untested_methods = @test_obj methods select: |m| {
+    #   m tests size == 0
+    # }
+    # untested_methods empty? if_false: {
+      # ["WARNING: These methods need tests:",
+      #  untested_methods map: 'name . select: |m| { m whitespace? not } . join: ", "] println
+    # }
+    Console newline
+  }
+
+
+  class SpecTest {
+    @@failed_positive = []
+    @@failed_negative = []
+
+    def SpecTest failed_test: actual_and_expected {
+      @@failed_positive << actual_and_expected
+    }
+
+    def SpecTest failed_negative_test: value {
+      @@failed_negative << value
+    }
+
+    def initialize: @info_str block: @block {
+      { @@failed_positive = [] } unless: @@failed_positive
+      { @@failed_negative = [] } unless: @@failed_negative
+    }
+
+    def run: test_obj {
+      @@failed_positive = []
+      @@failed_negative = []
+      try {
+        @block call
+      } catch IOError => e {
+        SpecTest failed_test: [e, "UNKNOWN"]
+      }
+
+      any_failure = nil
+      if: (@@failed_positive size > 0) then: {
+        any_failure = true
+        Console newline
+        "> FAILED: " ++ test_obj ++ " " ++ @info_str print
+        self print_failed_positive
+      }
+
+      if: (@@failed_negative size > 0) then: {
+        any_failure = true
+        Console newline
+        "> FAILED: " ++ test_obj ++ " " ++ @info_str print
+        self print_failed_negative
+      }
+
+      { "." print } unless: any_failure
+    }
+
+    def print_failed_positive {
+      " [" ++ (@@failed_positive size) ++ " unexpected values]" println
+      "Got: " println
+      @@failed_positive each: |f| {
+        "     " ++ (f first inspect) ++ " instead of: " ++ (f second inspect) println
+      }
+    }
+
+    def print_failed_negative {
+      " [" ++ (@@failed_negative size) ++ " unexpected values]" println
+      "Should not have gotten the following values: " println
+      @@failed_negative each: |f| {
+        "     " ++ (f inspect) println
+      }
+    }
+  }
+
+  class PositiveMatcher {
+    """PositiveMatcher expects its actual value to be equal to an
+       expected value.
+       If the values are not equal, a SpecTest failure is generated."""
+
+    def initialize: @actual_value {
+    }
+
+    def == expected_value {
+      unless: (@actual_value == expected_value) do: {
+        SpecTest failed_test: [@actual_value, expected_value]
+      }
+    }
+
+    def != expected_value {
+      unless: (@actual_value != expected_value) do: {
+        SpecTest failed_negative_test: @actual_value
+      }
+    }
+
+    def unknown_message: msg with_params: params {
+      """Forwardy any other message and parameters to the object itself
+         and checks the return value."""
+
+      unless: (@actual_value send: msg params: params) do: {
+        SpecTest failed_test: [@actual_value, params first]
+      }
+    }
+
+    def be: block {
+      unless: (block call: [@actual_value]) do: {
+        SpecTest failed_test: [@actual_value, nil]
+      }
+    }
+  }
+
+  class NegativeMatcher {
+    """NegativeMatcher expects its actual value to be unequal to an
+       expected value.
+       If the values are equal, a SpecTest failure is generated."""
+
+    def initialize: @actual_value {
+    }
+
+    def == expected_value {
+      if: (@actual_value == expected_value) then: {
+        SpecTest failed_negative_test: @actual_value
+      }
+    }
+
+    def != expected_value {
+      if: (@actual_value != expected_value) then: {
+        SpecTest failed_test: [@actual_value, expected_value]
+      }
+    }
+
+    def unknown_message: msg with_params: params {
+      """Forwardy any other message and parameters to the object itself
+         and checks the return value."""
+
+      if: (@actual_value send: msg params: params) then: {
+        SpecTest failed_negative_test: @actual_value
+      }
+    }
+
+    def be: block {
+      if: (block call: [@actual_value]) then: {
+        SpecTest failed_negative_test: @actual_value
+      }
+    }
+  }
+}
+
+class Object {
+  def should {
+    "Returns a PositiveMatcher for self."
+    FancySpec PositiveMatcher new: self
+  }
+
+  def should_not {
+    "Returns a NegativeMatcher for self."
+    FancySpec NegativeMatcher new: self
+  }
+}

data/lib/fdoc.fy

@@ -0,0 +1,359 @@
+# Load all of fancy.
+require: "boot"
+
+class Fancy FDoc {
+  """
+
+  FDoc is a tool to generate API documentation from Fancy source.
+
+  Works as follows:
+
+   1. We setup a handler to be invoked every time an object is set documentation
+      See fdoc_hook.fy, its loaded even before all of lib/rbx/*.fy so we can
+      Also have documentation for all fancy rubinius.
+   2. We load boot.fy, so we get documentation for all fancy's lib.
+   3. We run FDoc main
+      which can possibly load any file/directory you specify and optionally
+      run specs, effectively associating them with documented objects.
+   4. Generate output file.
+      Currently the plan is to output a json formatted object.
+      To be loaded by an html file and use jquery to build a GUI from it.
+
+  """
+
+  OUTPUT_DIR = "doc/api/"
+
+  def self main {
+    """
+     FDoc will load all .fy files you give to it, and optionally run
+     any specified FancySpec, and later produce documentation output.
+    """
+
+    output_dir = OUTPUT_DIR
+    ARGV for_option: "-o" do: |d| { output_dir = d }
+    require("fileutils")
+    FileUtils mkdir_p(output_dir)
+
+    # Currently we just load any files given on ARGV.
+    ARGV each: |file| { Fancy CodeLoader load_compiled_file(file) }
+
+    # by now simply produce a apidoc/fancy.jsonp file.
+    json = JSON new: @documented_objects
+    json write: (File expand_path("fancy.jsonp", output_dir))
+
+    ["Open your browser at " ++ output_dir ++ "index.html.",
+     " " ++ (json classes size) ++ " classes. ",
+     " " ++ (json methods size) ++ " methods. ",
+     " " ++ (json objects size) ++ " other objects. "] println
+  }
+
+
+  class JSON {
+
+    read_slots: ['classes, 'methods, 'blocks, 'objects]
+
+    def initialize: documented {
+      @documented_objects = documented
+
+      is_class = |o| { o kind_of?: Module }
+      is_method = |o| { o kind_of?: Rubinius CompiledMethod }
+      is_block = |o| { o kind_of?: Rubinius BlockEnvironment }
+      all_other = |o| {
+        [is_class, is_method, is_block] all?() |b| { b call: [o] == false }
+      }
+
+      @classes = @documented_objects keys select: is_class
+      @methods = @documented_objects keys select: is_method
+      @blocks =  @documented_objects keys select: is_block
+      @objects = @documented_objects keys select: all_other
+    }
+
+    def string_to_json: obj { obj to_s inspect }
+    def symbol_to_json: obj { obj to_s }
+
+    def array_to_json: obj {
+      str = ["["]
+      obj each: |i| { str << $ to_json: i } in_between: { str << ", " }
+      str << ["]"]
+      str join
+    }
+
+    def hash_to_json: obj {
+      str = ["{"]
+      keys = obj keys
+      keys each: |i| {
+        str << $ to_json: i
+        str << ":"
+        str << $ to_json: (obj at: i)
+      } in_between: { str << ", " }
+      str << "}"
+      str join
+    }
+
+    def to_json: obj {
+      # Reimplement now we have pattern matching dispatch.
+      match obj -> {
+        case Hash -> self hash_to_json: obj
+        case Array -> self array_to_json: obj
+        case Symbol -> self symbol_to_json: obj
+        case String -> self string_to_json: obj
+        case Numeric -> obj
+        case nil -> "null"
+        case _ -> "Dont know how to convert " ++ (obj inspect) ++ " to JSON" raise!
+      }
+    }
+
+    def popuplate_methods: cls on: attr type: type known: methods {
+      cls send(type ++ "s", false) each: |n| {
+        mattr = <[]>
+        exec = cls send(type, n) executable()
+        methods delete(exec)
+        mdoc = Fancy Documentation for: exec
+        if: mdoc then: {
+          mattr at: 'doc put: $ mdoc format: 'fdoc
+          if: (mdoc meta) then: {
+            mattr at: 'arg put: $ mdoc meta at: 'argnames
+          }
+        }
+        if: (exec class() == Rubinius CompiledMethod) then: {
+          relative_file = exec file()
+          # HACK: We simply delete everything before lib/
+          # TODO: Fix, either use a -r (root) option or use __FILE__
+          relative_file = relative_file to_s gsub(/.*lib/, "lib")
+          lines = exec lines() to_a()
+          mattr at: 'file put: $ relative_file
+          # TODO calculate line numbers from compiled method
+          # right now we only use the first line of code in the body.
+          mattr at: 'lines put: $ [lines[3], lines[3]]
+        }
+        attr[(type ++ "s") intern()] at: n put: mattr
+      }
+    }
+
+    def generate_map {
+      map = <['title => "Fancy Documentation", 'date => Time now() to_s(),
+              'classes => <[]>, 'methods => <[]>, 'objects => <[]> ]>
+
+      methods = @methods dup()
+
+      @classes each: |cls| {
+        name = cls name() gsub("::", " ")
+        doc = Fancy Documentation for: cls
+        attr = <[
+          'doc => doc format: 'fdoc,
+          'instance_methods => <[]>,
+          'methods => <[]>,
+          'ancestors => cls ancestors() map: |c| { c name() gsub("::", " ") }
+        ]>
+        popuplate_methods: cls on: attr type: 'instance_method known: methods
+        popuplate_methods: cls on: attr type: 'method known: methods
+        map['classes] at: name put: attr
+      }
+
+      methods each: |cm| {
+        cls = cm scope() module()
+        cls_name = cls name() gsub("::", " ")
+        cls_attr = map['classes] at: cls_name
+
+        full_name = cls_name ++ "#" ++ (cm name())
+
+        doc = Fancy Documentation for: cm
+        attr = <[
+          'args => doc meta at: 'argnames,
+          'doc => doc format: 'fdoc
+        ]>
+
+        map['methods] at: full_name put: attr
+      }
+
+      map
+    }
+
+
+    def write: filename call: name ("fancy.fdoc") {
+      map = self generate_map
+      json = self to_json: map
+      js = "(function() { " ++ name ++ "(" ++ json ++ "); })();"
+      File open: filename modes: ['write] with: |out| { out print: js }
+    }
+
+  }
+
+
+  class Formatter {
+    """
+    A documentation formater intended to be used by @FDoc@.
+
+    This formatter makes some transformations on a docstring
+    and then converts it to html using markdown.
+    """
+
+    Fancy Documentation formatter: 'fdoc is: |d| { format: d }
+
+
+    def self format: doc {
+      str = doc to_s
+      tags = <[ ]>
+      str = remove_indentation: str
+      str = remove_tags: str into: tags
+      str = create_tags: str with: tags
+      str = create_class_references: str
+      str = create_method_references: str
+      str = create_code: str
+      str = htmlize: str
+      str
+    }
+
+    def self remove_indentation: str {
+      """
+      Remove leading white space for multi-line strings.
+      This method expects the first character to be an line return.
+      """
+      m = /^(\r?\n)*(\s+)/ match(str)
+      str = str strip()
+      if: m then: {
+        pattern = "^ {" ++ (m[2] size()) ++ "}"
+        rex = Regexp.new(pattern)
+        str = str gsub(rex, "");
+      }
+      str
+    }
+
+    def self create_class_references: str {
+      """
+      Creates class references for Fancy class names.
+
+      A docstring may contain class names sorounded by @
+      without space between the @.
+
+      Nested classes can be indicated by using :: like
+
+        Foo::Bar
+
+      This will create references for both, @Foo and @Bar
+
+      Instance methods should be written:
+
+        Foo::Bar#baz
+
+      Class methods should be written:
+
+        Foo::Bar.baz
+
+      Some examples:
+
+      A simple class reference:
+
+      @Fancy@
+
+      Nested class reference:
+
+      @Fancy::FDoc@
+
+      A fancy method without arguments:
+
+      @Fancy::FDoc::JSON#:generate_map@
+
+      A ruby method reference (will link to ruby docs if available)
+
+      @String#split@
+
+      A fancy method with many arguments:
+
+      @Fancy::Package::Installer#initialize:version:install_path:@
+
+      A singleton method:
+
+      @Fancy::FDoc::Formatter~format:@
+
+      """
+      str gsub(/@[A-Z][^\r\n\s]+?@/) |cstr| {
+       names = cstr slice(1, cstr size() - 2) split("::")
+       refs = []
+       names each_with_index() |name, idx| {
+         n = name split(/[\#\~]/)
+         clas = names take(idx) + [n[0]] . join(" ")
+         html = "<code data-lang=\"fancy\" data-class-ref=\"" ++ .
+              clas ++ "\" class=\"class-ref selectable\">" ++ (n[0]) ++ "</code>"
+         refs << html
+
+         # Generate a reference for last method if availble.
+         if: (n[1]) then: {
+           method = n[1]
+           if: (method start_with?(":")) then: {
+             method = method sub(/^:/, "")
+           }
+           sigil = ""
+           name =~ (Regexp.new("^#")) . if_do: { sigil = "<small>#</small>" }
+           type = n[1] include?(":") . if_do: {
+             if: (sigil == "") then: {
+               "singleton-method-ref"
+             } else: {
+               "instance-method-ref"
+             }
+           } else: {
+             if: (sigil == "") then: {
+               "ruby-singleton-method-ref"
+             } else: {
+               "ruby-instance-method-ref"
+             }
+           }
+
+           html = sigil ++ "<code data-lang=\"fancy\" data-" ++ type ++ "=\"" ++ .
+              (n[1]) ++ "\" " ++ " data-owner-class=\"" ++ clas ++ "\" " ++ .
+              "class=\"" ++ type ++ " selectable\">" ++ method ++ "</code>"
+           refs << html
+         }
+       }
+       refs join(" ")
+      }
+    }
+
+    def self remove_tags: str into: map {
+      ary = str split(/\r?\n/) map: |line| {
+        m = /^@([a-z@]\S+?)\s+(.*)/ match(line)
+        if: m then: {
+          map at: (m[1]) put: (m[2])
+          nil
+        } else: {
+          line
+        }
+      }
+      ary compact join("\n")
+    }
+
+    def self create_tags: str with: map {
+      tags = map map: |pair| {
+        name = pair[0]
+        value = pair[1]
+        "<div class=\"doctag\"><label> @" ++ name ++ .
+          " </label><div>" ++ value ++ "</div></div>"
+      }
+      str ++ "\n<div class=\"doctags\">" ++ (tags join()) ++ "</div>"
+    }
+
+    def self create_code: str {
+      str gsub(/@([^\s,\]\)\}\.]+)/,
+               "<code data-lang=\"fancy\">\\1</code>")
+    }
+
+    def self htmlize: str {
+      require("rubygems")
+      require("rdiscount")
+      RDiscount new(str) to_html()
+    }
+
+    def self create_method_references: str {
+      # First methods ending with :
+      str gsub(/@([a-z_:]+:)@/,
+               "<code data-lang=\"fancy\" data-method=\"\\1\" class=\"selectable\">\\1</code>") .
+      # fancy methods starting with : (argless fancy methods)
+      gsub(/@:([a-z_]+)@/,
+           "<code data-lang=\"fancy\" data-method=\":\\1\" class=\"selectable\">\\1</code>")
+    }
+
+  }
+
+}
+
+Fancy FDoc main