fancy 0.7.0 → 0.8.0

data/lib/enumerator.fy

@@ -135,7 +135,7 @@ class Fancy {
       loop: {
         try {
           block call: [next]
-        } catch (Fancy StopIteration) => ex {
+        } catch Fancy StopIteration {
           return self
         }
       }

data/lib/eval.fy

@@ -1,28 +1,42 @@
 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(),
+def Fancy eval: code binding: binding (nil) file: file ("(fancy-eval)") line: line (1) {
+  """
+  @code @String@ of Fancy code to be evaluated.
+  @binding @Binding@ to evaluate @code in.
+  @file @String that is the name of @File@ from which @code is evaluated from (if any).
+  @line Starting line, defaults to 1.
+  """
+
+  binding if_nil: {
+    binding = 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 = Fancy Compiler compile_code: code vars: (binding variables()) file: file line: line
+
+  # Binding#static_scope was renamed to Binding#constant_scope a while ago.
+  # if the new version fails, retry with the old name for backwards compatibility (for now).
+  try {
+    cm scope=(binding constant_scope() dup())
+  } catch NoMethodError {
+    cm scope=(binding static_scope() dup())
+  }
   cm name=('__fancy_eval__)
 
   script = Rubinius CompiledMethod Script new(cm, file, true)
-  script eval_binding=(bnd)
+  script eval_binding=(binding)
   script eval_source=(code)
 
   cm scope() script=(script)
 
   be = Rubinius BlockEnvironment new()
-  be under_context(bnd variables(), cm)
+  be under_context(binding variables(), cm)
 
-  if: (bnd from_proc?()) then: {
-    be proc_environment=(bnd proc_environment)
+  if: (binding from_proc?()) then: {
+    be proc_environment=(binding proc_environment)
   }
 
   be from_eval!()

data/lib/exception.fy

@@ -0,0 +1,16 @@
+class StandardError {
+  def self raise: message {
+    """
+    Raises new @Exception@ with @message.
+
+    Example:
+          StandardError raise: \"Error!\"
+          ArgumentError raise: \"Missing argument!\"
+          # is the same as:
+          StandardError new: \"Error!\” . raise!
+          ArgumentError new: \"Missing argument!\" . raise!
+    """
+
+    new: message . raise!
+  }
+}

data/lib/false_class.fy

@@ -10,45 +10,76 @@ class FalseClass {
   }
 
   def if_true: block {
-    "Returns @nil."
+    """
+    @return @nil.
+    """
+
     nil
   }
 
   def if_true: then_block else: else_block {
-    "Calls @else_block."
+    """
+    Calls @else_block.
+    """
+
     else_block call
   }
 
   def if_false: block {
+    """
+    Calls @block with @self.
+    """
+
     block call: [self]
   }
 
   def if_false: then_block else: else_block {
+    """
+    Calls @then_block with @self.
+    """
+
     then_block call: [self]
   }
 
   def if_nil: then_block {
+    """
+    @return @nil.
+    """
+
     nil
   }
 
   def if_nil: then_block else: else_block {
+    """
+    Calls @else_block with @self.
+    """
+
     else_block call: [self]
   }
 
   def false? {
-    "Returns @true."
+    """
+    @return @true.
+    """
+
     true
   }
 
   def to_s {
-    "Returns @false as a @String@."
+    """
+    @return @false as a @String@.
+    """
+
     "false"
   }
 
   alias_method: 'inspect for: 'to_s
 
   def to_a {
-    "Returns an empty @Array@."
+    """
+    @return An empty @Array@.
+    """
+
     []
   }
 

data/lib/fancy_spec.fy

@@ -20,6 +20,7 @@ class FancySpec {
     Factory method for creating FancySpec instances.
     Calls @block with the new FancySpec instance as the receiver, then runs it.
 
+    Example:
           FancySpec describe: MyTestClass with: {
             # test cases using it:for:when: here.
           }
@@ -32,8 +33,9 @@ class FancySpec {
 
   def FancySpec describe: description for: test_obj with: block {
     """
-    Similar to FancySpec##describe:with: but also taking an explicit @test_obj.
+    Similar to @FancySpec~describe:with:@ but also taking an explicit @test_obj.
 
+    Example:
           FancySpec describe: \"My cool class\" for: MyCoolClass with: {
             # test cases using it:for:when: here.
           }
@@ -53,7 +55,7 @@ class FancySpec {
           it: \"should be an empty Array\" when: {
             arr = [1,2,3]
             3 times: { arr pop }
-            arr empty? is == true
+            arr empty? is: true
           }
     """
 
@@ -71,19 +73,23 @@ class FancySpec {
           it: \"should be an empty Array\" with: 'empty? when: {
             arr = [1,2,3]
             3 times: { arr pop }
-            arr empty? is == true
+            arr empty? is: true
           }
     """
 
     test = SpecTest new: spec_info_string block: spec_block
-    # try {
-    #   @test_obj method: method_name . if_true: |method| {
-    #     method tests << test
-    #   }
-    # } catch MethodNotFoundError => e {
-    #   # ignore errors
-    # }
+
     @spec_tests << test
+
+    match @test_obj {
+      case Class ->
+        has_method? = @test_obj has_method?: method_name
+        { has_method? = @test_obj metaclass has_method?: method_name } unless: has_method?
+
+        unless: has_method? do: {
+          SpecTest method_not_found: method_name for: @test_obj
+        }
+    }
   }
 
   alias_method: 'it:for:when: for: 'it:with:when:
@@ -142,6 +148,7 @@ class FancySpec {
     @@failed_count = 0
     @@total_tests = 0
     @@total_expectations = 0
+    @@methods_not_found = <[]>
 
     def SpecTest add_expectation {
       @@total_expectations = @@total_expectations + 1
@@ -171,29 +178,43 @@ class FancySpec {
       @@failed_count = @@failed_count + 1
     }
 
+    def SpecTest method_not_found: method_name for: type {
+      { @@methods_not_found[type]: []} unless: $ @@methods_not_found[type]
+      @@methods_not_found[type] << method_name
+    }
+
     def SpecTest current {
       @@current
     }
 
     def SpecTest print_failures: start_time no_failures: ok_block else: error_block {
-      @@failed_positive each: |test_obj failed_tests| {
-        failed_tests each: |t| {
-          Console newline
-          "> FAILED: " ++ test_obj ++ " " ++ (t info_str) print
-          t print_failed_positive
+      let: '*stdout* be: *stderr* in: {
+        @@failed_positive each: |test_obj failed_tests| {
+          failed_tests each: |t| {
+            "\n> FAILED: " ++ test_obj ++ " " ++ (t info_str) print
+            t print_failed_positive
+          }
         }
-      }
 
-      @@failed_negative each: |test_obj failed_tests| {
-        failed_tests each: |t| {
-          Console newline
-          "> FAILED: " ++ test_obj ++ " " ++ (t info_str) print
-          t print_failed_negative
+        @@failed_negative each: |test_obj failed_tests| {
+          failed_tests each: |t| {
+            "\n> FAILED: " ++ test_obj ++ " " ++ (t info_str) print
+            t print_failed_negative
+          }
         }
+
+        unless: (@@methods_not_found empty? ) do: {
+          "The following methods were referenced in tests but could not be found:" println
+          max_size = @@methods_not_found keys map: @{ to_s size } . max
+          @@methods_not_found each: |type, methods| {
+            *stdout* printf("%-#{max_size}s : ", type)
+            methods map: @{ to_fancy_message } . join: ", " . println
+          }
+        }
+
+        "\nRan #{@@total_tests} tests (#{@@total_expectations} expectations) with #{@@failed_count} failures in #{Time now - start_time} seconds." println
       }
 
-      Console newline
-      "Ran #{@@total_tests} tests (#{@@total_expectations} expectations) with #{@@failed_count} failures in #{Time now - start_time} seconds." println
       if: (@@failed_count == 0) then: ok_block else: error_block
     }
 
@@ -210,8 +231,8 @@ class FancySpec {
       @@total_tests = @@total_tests + 1
       try {
         @block call_with_receiver: self
-      } catch Exception => e {
-        failed: (e, "No Exception")
+      } catch StandardError => e {
+        failed: (e, "No Exception") location: (e backtrace)
       }
 
       if: failed? then: {
@@ -221,14 +242,18 @@ class FancySpec {
       }
     }
 
-    def failed: actual_and_expected {
-      @failed_positive << (actual_and_expected, caller(5) at: 0)
+    def failed: actual_and_expected location: location (nil) {
+      unless: location do: {
+        location = caller() find: |l| { l =~ /__script__/ }
+      }
+      @failed_positive << (actual_and_expected, location)
       SpecTest failed_test: self
     }
 
     def failed_negative: value {
       { value = [value, 'negative_failure] } unless: $ value responds_to?: 'at:
-      @failed_negative << (value, caller(6) at: 0)
+      location = caller() find: |l| { l =~ /__script__/ }
+      @failed_negative << (value, location)
       SpecTest failed_negative_test: self
     }
 
@@ -251,10 +276,15 @@ class FancySpec {
     def print_failed_common: failures {
       failures each: |f| {
         actual, expected = f first
-        location = f second gsub(/:(\d+):in `[^']+'/, " +\1")
-        location = location split: "/" . from: -2 to: -1 . join: "/"
+        locations = f second
+
+        locations to_a map: |loc| {
+          loc = loc gsub(/:(\d+):in `[^']+'/, " +\1")
+          file, line = loc split: " +"
+          loc = "#{file} +#{line to_i - 1}" # somehow line is off by +1
+          loc = loc split: (Directory pwd + "/") . second
+        } . compact println
 
-        location println
         unless: (expected == 'negative_failure) do: {
           "    Expected: #{expected inspect}" println
           "    Received: #{actual inspect}" println
@@ -296,7 +326,7 @@ class FancySpec {
         SpecTest current failed: (nil, exception_class)
       } catch exception_class {
         # ok
-      } catch Exception => e {
+      } catch StandardError => e {
         SpecTest current failed: (e class, exception_class)
       }
     }
@@ -309,7 +339,7 @@ class FancySpec {
       } catch exception_class => e {
         block call: [e]
         # ok
-      } catch Exception => e {
+      } catch StandardError => e {
         SpecTest current failed: (e class, exception_class)
       }
     }
@@ -360,7 +390,7 @@ class FancySpec {
         @actual_value call
       } catch exception_class {
         SpecTest current failed_negative: (exception_class, nil)
-      } catch Exception => e {
+      } catch StandardError {
         true
         # ok
       }

data/lib/fdoc.fy

@@ -1,9 +1,12 @@
 # Load all of fancy.
+require: "rbx/documentation"
+require: "fdoc_hook"
 require: "boot"
+require: "option_parser"
+require: "fancy_spec"
 
 class Fancy FDoc {
   """
-
   FDoc is a tool to generate API documentation from Fancy source.
 
   Works as follows:
@@ -18,30 +21,72 @@ class Fancy FDoc {
    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/"
+  FANCY_ROOT_DIR = __FILE__ relative_path: "../"
 
   def self main {
     """
-     FDoc will load all .fy files you give to it, and optionally run
-     any specified FancySpec, and later produce documentation output.
+    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 }
+    with_stdlib = false
+    add_github_links = false
+    github_repo = "bakkdoor/fancy"
+
+    OptionParser new: @{
+      remove_after_parsed: true
+      banner: "Usage: fdoc [options] [source_files]\nOptions:"
+
+      with: "-o [output_dir]" doc: "Sets output directory of generated documentation page, defaults to #{output_dir}" do: |dir| {
+        output_dir = dir
+      }
+
+      with: "-github-repo [repo_url]" doc: "Sets the Github repository to link to method definitions. Example: -github-repo bakkdoor/redis.fy" do: |url| {
+        github_repo = url
+        add_github_links = true
+      }
+
+      with: "--with-stdlib" doc: "Include Fancy's standard library in generated documentation" do: {
+        with_stdlib = true
+      }
+    } . parse: ARGV
+
+    output_dir = File absolute_path: output_dir . + "/"
+
     require("fileutils")
     FileUtils mkdir_p(output_dir)
 
+    # check if we're in Fancy's root dir
+    # if not, copy fdoc related files over to output_dir
+    if: (output_dir relative_path: "../" == FANCY_ROOT_DIR) then: {
+      # add stdlib by default when in FANCY_ROOT_DIR
+      with_stdlib = true
+      add_github_links = true
+    } else: {
+      files = Dir list: "#{FANCY_ROOT_DIR}/doc/api/*" . reject: |f| { f =~ /fancy\.jsonp$/ }
+      FileUtils cp(files, output_dir)
+    }
+
+    if: with_stdlib then: {
+      @objects_to_remove = <[]>
+    } else: {
+      @objects_to_remove = @documented_objects dup
+    }
+
     # Currently we just load any files given on ARGV.
     ARGV each: |file| { Fancy CodeLoader load_compiled_file(file) }
 
+    @documented_objects = @documented_objects select_keys: |k| { @objects_to_remove includes?: k . not }
+
     # by now simply produce a apidoc/fancy.jsonp file.
-    json = JSON new: @documented_objects
+    json = JSON new: @documented_objects add_github_links: add_github_links github_repo: github_repo
     json write: (File expand_path("fancy.jsonp", output_dir))
 
-    ["Open your browser at " ++ output_dir ++ "index.html.",
+    ["Open your browser at " ++ output_dir ++ "index.html ",
      " " ++ (json classes size) ++ " classes. ",
      " " ++ (json methods size) ++ " methods. ",
      " " ++ (json objects size) ++ " other objects. "] println
@@ -49,10 +94,9 @@ class Fancy FDoc {
 
 
   class JSON {
-
     read_slots: ['classes, 'methods, 'blocks, 'objects]
 
-    def initialize: documented {
+    def initialize: documented add_github_links: @add_github_links github_repo: @github_repo {
       @documented_objects = documented
 
       is_class = |o| { o kind_of?: Module }
@@ -68,8 +112,13 @@ class Fancy FDoc {
       @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 string_to_json: obj {
+      obj to_s inspect
+    }
+
+    def symbol_to_json: obj {
+      obj to_s
+    }
 
     def array_to_json: obj {
       str = ["["]
@@ -125,7 +174,7 @@ class Fancy FDoc {
           mattr['file]: $ relative_file
           # TODO calculate line numbers from compiled method
           # right now we only use the first line of code in the body.
-          mattr['lines]: $ [lines[3], lines[3]]
+          mattr['lines]: $ [exec definition_line, exec last_line]
         }
         attr[(type ++ "s") intern()] [n]: mattr
       }
@@ -170,17 +219,14 @@ class Fancy FDoc {
       map
     }
 
-
     def write: filename call: name ("fancy.fdoc") {
       map = generate_map
       json = to_json: map
-      js = "(function() { " ++ name ++ "(" ++ json ++ "); })();"
+      js = "(function() { #{name}(#{@add_github_links}, #{@github_repo inspect}, #{json}); })();"
       File open: filename modes: ['write] with: |out| { out print: js }
     }
-
   }
 
-
   class Formatter {
     """
     A documentation formater intended to be used by @FDoc@.
@@ -191,7 +237,6 @@ class Fancy FDoc {
 
     Fancy Documentation formatter: 'fdoc is: |d| { format: d }
 
-
     def self format: doc {
       str = doc to_s
       tags = <[ ]>
@@ -200,8 +245,8 @@ class Fancy FDoc {
       str = create_tags: str with: tags
       str = create_class_references: str
       str = create_method_references: str
-      str = create_code: str
       str = htmlize: str
+      str = create_code: str
       str
     }
 
@@ -240,6 +285,7 @@ class Fancy FDoc {
       A singleton method:
       @Fancy::FDoc::Formatter~format:@
       """
+
       str gsub(/@[A-Z][^\r\n\s]+?@/) |cstr| {
        names = cstr slice(1, cstr size() - 2) split("::")
        refs = []
@@ -296,18 +342,35 @@ class Fancy FDoc {
     }
 
     def self create_tags: str with: map {
+      max_width = map map: @{ first size } . max
       tags = map map: |pair| {
         name = pair[0]
         value = pair[1]
-        "<div class=\"doctag\"><label> @" ++ name ++ .
-          " </label><div>" ++ value ++ "</div></div>"
+        # make argument names all align nicely:
+        name = name + ("&nbsp;" * (max_width - (name size)))
+        "<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>")
+      md = /<pre>/ match: str
+      if: md then: {
+        md = /<pre>/ match: str
+        pre_code = md pre_match
+        md = /</pre>/ match: $ md post_match
+        code, post_code = md pre_match, md post_match
+
+        pre_code = pre_code gsub(/@([^\s,@\]\)\{\}\.]+)/,
+                                 "<code data-lang=\"fancy\">\\1</code>")
+        post_code = post_code gsub(/@([^\s,@\]\)\{\}\.]+)/,
+                                  "<code data-lang=\"fancy\">\\1</code>")
+
+        "#{pre_code}<pre>#{code}</pre>#{post_code}"
+      } else: {
+        str gsub(/@([^\s,@\]\)\{\}\.]+)/,
+                 "<code data-lang=\"fancy\">\\1</code>")
+      }
     }
 
     def self htmlize: str {
@@ -324,9 +387,7 @@ class Fancy FDoc {
       gsub(/@:([a-z_]+)@/,
            "<code data-lang=\"fancy\" data-method=\":\\1\" class=\"selectable\">\\1</code>")
     }
-
   }
-
 }
 
 Fancy FDoc main