jsduck 0.2 → 0.3

data/README.md

@@ -106,10 +106,11 @@ For hacking fork it from github.
     $ cd jsduck
     $ rake --tasks
 
-JsDuck depends on [json][] and [RDiscount][] plus [RSpec][] for tests.
+JsDuck depends on [json][], [RDiscount][], and [parallel][] plus [RSpec][] for tests.
 
 [json]: http://flori.github.com/json/
 [RDiscount]: https://github.com/rtomayko/rdiscount
+[parallel]: https://github.com/grosser/parallel
 [RSpec]: http://rspec.info/
 
 
@@ -182,10 +183,6 @@ Missing features and TODO
 * Support for custom @tags. Ext-doc supports this, I personally have
   never used this feature, so I'm thinking it's not really needed.
 
-* Speed improvements. JsDuck is clearly slower than ext-doc, but I
-  haven't so far done almost no optimizations, so there should be some
-  pretty low-hanging fruits to pick.
-
 
 Copying
 -------
@@ -198,6 +195,14 @@ JsDuck was developed by [Rene Saarsoo](http://triin.net).
 Changelog
 ---------
 
+* 0.3 - Performance improvements
+  * Significant peed improvements - most importantly utilizing
+    multiple CPU-s (if available) to speed things up.  On my 4-core
+    box JsDuck is now even faster than ext-doc.
+  * Printing of performance info in verbose mode
+  * Support for comma-first coding style
+  * Few other fixes to JavaScript parsing
+
 * 0.2 - most features of ext-doc supported.
   * Links from documentation to source code
   * Syntax highlighting of code examples

data/jsduck.gemspec

@@ -2,8 +2,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.7"
 
   s.name = 'jsduck'
-  s.version = '0.2'
-  s.date = '2011-01-10'
+  s.version = '0.3'
+  s.date = '2011-02-08'
   s.summary = "Simple JavaScript Duckumentation generator"
   s.description = "Better ext-doc like JavaScript documentation generator for ExtJS"
   s.homepage = "https://github.com/nene/jsduck"
@@ -11,11 +11,15 @@ Gem::Specification.new do |s|
   s.email = "nene@triin.net"
   s.rubyforge_project = s.name
 
-  s.files = `git ls-files`.split("\n").find_all {|file| file !~ /spec.rb$/ }
+  s.files = `git ls-files`.split("\n").find_all do |file|
+    file !~ /spec.rb$/ && file !~ /benchmark/
+  end
+
   s.executables = ["jsduck"]
 
   s.add_dependency 'rdiscount'
   s.add_dependency 'json'
+  s.add_dependency 'parallel'
 
   s.require_path = 'lib'
 end

data/lib/jsduck/aggregator.rb

@@ -1,5 +1,3 @@
-require 'jsduck/parser'
-require 'jsduck/doc_parser'
 require 'jsduck/merger'
 
 module JsDuck
@@ -12,22 +10,21 @@ module JsDuck
       @classes = {}
       @orphans = []
       @current_class = nil
-      @doc_parser = DocParser.new
       @merger = Merger.new
     end
 
-    # Parses chunk of JavaScript.  The resulting documentation is
-    # accumulated inside this class and can be later accessed through
-    # #result method.
+    # Combines chunk of parsed JavaScript together with previously
+    # added chunks.  The resulting documentation is accumulated inside
+    # this class and can be later accessed through #result method.
     #
-    # - input  the JavaScript source
+    # - input  parse result from JsDuck::Parser
     # - filename  name of the JS file where it came from
     # - html_filename  name of the HTML file where the source was saved.
     #
-    def parse(input, filename="", html_filename="")
+    def aggregate(input, filename="", html_filename="")
       @current_class = nil
-      Parser.new(input).parse.each do |docset|
-        doc = @doc_parser.parse(docset[:comment])
+      input.each do |docset|
+        doc = docset[:comment]
         code = docset[:code]
         href = html_filename + "#line-" + docset[:linenr].to_s
         register(add_href(@merger.merge(doc, code), href, filename))

data/lib/jsduck/app.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'jsduck/parser'
 require 'jsduck/aggregator'
 require 'jsduck/source_formatter'
 require 'jsduck/class'
@@ -6,8 +7,10 @@ require 'jsduck/tree'
 require 'jsduck/tree_icons'
 require 'jsduck/subclasses'
 require 'jsduck/page'
+require 'jsduck/timer'
 require 'json'
 require 'fileutils'
+require 'parallel'
 
 module JsDuck
 
@@ -24,26 +27,42 @@ module JsDuck
       @template_dir = nil
       @input_files = []
       @verbose = false
+      @timer = Timer.new
     end
 
     # Call this after input parameters set
     def run
       copy_template(@template_dir, @output_dir)
-      classes = filter_classes(parse_files(@input_files))
-      write_tree(@output_dir+"/output/tree.js", classes)
-      write_pages(@output_dir+"/output", classes)
+
+      parsed_files = @timer.time(:parsing) { parallel_parse(@input_files) }
+      result = @timer.time(:aggregating) { aggregate(parsed_files) }
+      classes = @timer.time(:aggregating) { filter_classes(result) }
+      @timer.time(:generating) { write_tree(@output_dir+"/output/tree.js", classes) }
+      @timer.time(:generating) { write_pages(@output_dir+"/output", classes) }
+
+      @timer.report if @verbose
     end
 
-    # Given array of filenames, parses all files and returns array of
-    # documented items in all of those files.
-    def parse_files(filenames)
-      agr = Aggregator.new
+    # Parses the files in parallel using as many processes as available CPU-s
+    def parallel_parse(filenames)
       src = SourceFormatter.new(@output_dir + "/source")
-      filenames.each do |fname|
+      Parallel.map(filenames) do |fname|
         puts "Parsing #{fname} ..." if @verbose
         code = IO.read(fname)
-        src_fname = src.write(code, fname)
-        agr.parse(code, File.basename(fname), File.basename(src_fname))
+        {
+          :name => fname,
+          :src_name => src.write(code, fname),
+          :data => Parser.new(code).parse,
+        }
+      end
+    end
+
+    # Aggregates parsing results sequencially
+    def aggregate(parsed_files)
+      agr = Aggregator.new
+      parsed_files.each do |file|
+        puts "Aggregating #{file[:name]} ..." if @verbose
+        agr.aggregate(file[:data], File.basename(file[:name]), File.basename(file[:src_name]))
       end
       agr.result
     end
@@ -73,12 +92,15 @@ module JsDuck
     end
 
     # Writes documentation page for each class
+    # We do it in parallel using as many processes as available CPU-s
     def write_pages(path, docs)
       subclasses = Subclasses.new(docs)
-      docs.each do |cls|
+      cache = {}
+      Parallel.each(docs) do |cls|
         filename = path + "/" + cls[:name] + ".html"
         puts "Writing to #{filename} ..." if @verbose
-        File.open(filename, 'w') {|f| f.write( Page.new(cls, subclasses).to_html ) }
+        html = Page.new(cls, subclasses, cache).to_html
+        File.open(filename, 'w') {|f| f.write(html) }
       end
     end
 

data/lib/jsduck/cfg_table.rb

@@ -3,8 +3,8 @@ require 'jsduck/table'
 module JsDuck
 
   class CfgTable < Table
-    def initialize(cls)
-      super(cls)
+    def initialize(cls, cache={})
+      super(cls, cache)
       @type = :cfg
       @id = @cls.full_name + "-configs"
       @title = "Config Options"

data/lib/jsduck/doc_parser.rb

@@ -48,7 +48,7 @@ module JsDuck
       # - and those without it
       input.each_line do |line|
         line.chomp!
-        if line =~ /\A\s*\*\s?(.*)\Z/ then
+        if line =~ /\A\s*\*\s?(.*)\Z/
           result << $1
         else
           result << line
@@ -64,39 +64,39 @@ module JsDuck
     def parse_loop
       add_tag(:default)
       while !@input.eos? do
-        if look(/@class\b/) then
+        if look(/@class\b/)
           at_class
-        elsif look(/@extends\b/) then
+        elsif look(/@extends\b/)
           at_extends
-        elsif look(/@singleton\b/) then
+        elsif look(/@singleton\b/)
           boolean_at_tag(/@singleton/, :singleton)
-        elsif look(/@event\b/) then
+        elsif look(/@event\b/)
           at_event
-        elsif look(/@method\b/) then
+        elsif look(/@method\b/)
           at_method
-        elsif look(/@constructor\b/) then
+        elsif look(/@constructor\b/)
           boolean_at_tag(/@constructor/, :constructor)
-        elsif look(/@param\b/) then
+        elsif look(/@param\b/)
           at_param
-        elsif look(/@returns?\b/) then
+        elsif look(/@returns?\b/)
           at_return
-        elsif look(/@cfg\b/) then
+        elsif look(/@cfg\b/)
           at_cfg
-        elsif look(/@property\b/) then
+        elsif look(/@property\b/)
           at_property
-        elsif look(/@type\b/) then
+        elsif look(/@type\b/)
           at_type
-        elsif look(/@xtype\b/) then
+        elsif look(/@xtype\b/)
           at_xtype
-        elsif look(/@member\b/) then
+        elsif look(/@member\b/)
           at_member
-        elsif look(/@static\b/) then
+        elsif look(/@static\b/)
           boolean_at_tag(/@static/, :static)
-        elsif look(/@(private|ignore|hide|protected)\b/) then
+        elsif look(/@(private|ignore|hide|protected)\b/)
           boolean_at_tag(/@(private|ignore|hide|protected)/, :private)
-        elsif look(/@/) then
+        elsif look(/@/)
           @current_tag[:doc] += @input.scan(/@/)
-        elsif look(/[^@]/) then
+        elsif look(/[^@]/)
           @current_tag[:doc] += @input.scan(/[^@]+/)
         end
       end
@@ -183,9 +183,9 @@ module JsDuck
       match(/@type/)
       add_tag(:type)
       skip_horiz_white
-      if look(/\{/) then
+      if look(/\{/)
         @current_tag[:type] = typedef
-      elsif look(/\S/) then
+      elsif look(/\S/)
         @current_tag[:type] = @input.scan(/\S+/)
       end
       skip_white
@@ -217,7 +217,7 @@ module JsDuck
     # matches {type} if possible and sets it on @current_tag
     def maybe_type
       skip_horiz_white
-      if look(/\{/) then
+      if look(/\{/)
         @current_tag[:type] = typedef
       end
     end
@@ -225,7 +225,7 @@ module JsDuck
     # matches identifier name if possible and sets it on @current_tag
     def maybe_name
       skip_horiz_white
-      if look(/\w/) then
+      if look(/\w/)
         @current_tag[:name] = ident
       end
     end
@@ -233,7 +233,7 @@ module JsDuck
     # matches ident.chain if possible and sets it on @current_tag
     def maybe_ident_chain(propname)
       skip_horiz_white
-      if look(/\w/) then
+      if look(/\w/)
         @current_tag[propname] = ident_chain
       end
     end

data/lib/jsduck/event_table.rb

@@ -5,8 +5,8 @@ require 'jsduck/long_params'
 module JsDuck
 
   class EventTable < Table
-    def initialize(cls)
-      super(cls)
+    def initialize(cls, cache={})
+      super(cls, cache)
       @type = :event
       @id = @cls.full_name + "-events"
       @title = "Public Events"

data/lib/jsduck/lexer.rb

@@ -38,7 +38,7 @@ module JsDuck
         tok = @tokens[i]
         i += 1
         return false if tok == nil
-        if t.instance_of?(Symbol) then
+        if t.instance_of?(Symbol)
           tok[:type] == t
         else
           tok[:value] == t
@@ -67,40 +67,60 @@ module JsDuck
     end
 
     # Goes through the whole input and tokenizes it
+    #
+    # For efficency we look for tokens in order of frequency in
+    # JavaScript source code:
+    #
+    # - first check for most common operators.
+    # - then for identifiers and keywords.
+    # - then strings
+    # - then comments
+    #
+    # The remaining token types are less frequent, so these are left
+    # to the end.
+    #
     def tokenize
       @tokens = []
       while !@input.eos? do
-        skip_white_and_comments
-        if @input.check(/[0-9]+/) then
+        skip_white
+        if @input.check(/[.(),;={}:]/)
           @tokens << {
-            :type => :number,
-            :value => eval(@input.scan(/[0-9]+(\.[0-9]*)?/))
+            :type => :operator,
+            :value => @input.scan(/./)
           }
-        elsif @input.check(/\w+/) then
+        elsif @input.check(/[a-zA-Z_]/)
           value = @input.scan(/\w+/)
           @tokens << {
             :type => KEYWORDS[value] ? :keyword : :ident,
             :value => value
           }
-        elsif @input.check(/\/\*\*/) then
-          @tokens << {
-            :type => :doc_comment,
-            # Calculate current line number, starting with 1
-            :linenr => @input.string[0...@input.pos].count("\n") + 1,
-            :value => @input.scan_until(/\*\/|\Z/)
-          }
-        elsif @input.check(/"/) then
+        elsif @input.check(/'/)
           @tokens << {
             :type => :string,
-            :value => eval(@input.scan(/"([^"\\]|\\.)*"/))
+            :value => eval(@input.scan(/'([^'\\]|\\.)*'/))
           }
-        elsif @input.check(/'/) then
+        elsif @input.check(/"/)
           @tokens << {
             :type => :string,
-            :value => eval(@input.scan(/'([^'\\]|\\.)*'/))
+            :value => eval(@input.scan(/"([^"\\]|\\.)*"/))
           }
-        elsif @input.check(/\//) then
-          if regex? then
+        elsif @input.check(/\//)
+          # Several things begin with dash:
+          # - comments, regexes, division-operators
+          if @input.check(/\/\*\*/)
+            @tokens << {
+              :type => :doc_comment,
+              # Calculate current line number, starting with 1
+              :linenr => @input.string[0...@input.pos].count("\n") + 1,
+              :value => @input.scan_until(/\*\/|\Z/)
+            }
+          elsif @input.check(/\/\*/)
+            # skip multiline comment
+            @input.scan_until(/\*\/|\Z/)
+          elsif @input.check(/\/\//)
+            # skip line comment
+            @input.scan_until(/\n|\Z/)
+          elsif regex?
             @tokens << {
               :type => :regex,
               :value => @input.scan(/\/([^\/\\]|\\.)*\/[gim]*/)
@@ -111,7 +131,20 @@ module JsDuck
               :value => @input.scan(/\//)
             }
           end
-        elsif @input.check(/./) then
+        elsif @input.check(/[0-9]+/)
+          nr = @input.scan(/[0-9]+(\.[0-9]*)?/)
+          @tokens << {
+            :type => :number,
+            # When number ends with ".", append "0" so Ruby eval will work
+            :value => eval(/\.$/ =~ nr ? nr+"0" : nr)
+          }
+        elsif @input.check(/\$/)
+          value = @input.scan(/\$\w*/)
+          @tokens << {
+            :type => :ident,
+            :value => value
+          }
+        elsif  @input.check(/./)
           @tokens << {
             :type => :operator,
             :value => @input.scan(/./)
@@ -128,7 +161,7 @@ module JsDuck
     # - closing square-bracket ]
     # Otherwise it's a beginning of regex
     def regex?
-      if @tokens.last then
+      if @tokens.last
         type = @tokens.last[:type]
         value = @tokens.last[:value]
         if type == :ident || type == :number
@@ -142,26 +175,6 @@ module JsDuck
       return true
     end
 
-    def skip_white_and_comments
-      skip_white
-      while multiline_comment? || line_comment? do
-        if multiline_comment? then
-          @input.scan_until(/\*\/|\Z/)
-        elsif line_comment? then
-          @input.scan_until(/\n|\Z/)
-        end
-        skip_white
-      end
-    end
-
-    def multiline_comment?
-      @input.check(/\/\*[^*]/)
-    end
-
-    def line_comment?
-      @input.check(/\/\//)
-    end
-
     def skip_white
       @input.scan(/\s+/)
     end

data/lib/jsduck/method_table.rb

@@ -5,8 +5,8 @@ require 'jsduck/long_params'
 module JsDuck
 
   class MethodTable < Table
-    def initialize(cls)
-      super(cls)
+    def initialize(cls, cache={})
+      super(cls, cache)
       @type = :method
       @id = @cls.full_name + "-methods"
       @title = "Public Methods"

data/lib/jsduck/page.rb

@@ -9,9 +9,16 @@ module JsDuck
 
   # Creates HTML documentation page for one class.
   class Page
-    def initialize(cls, subclasses = {})
+    # Initializes doc page generator
+    #
+    # - cls : the Class object for which to generate documentation
+    # - subclasses : lookup table for easy access to subclasses
+    # - cache : cache for already generated HTML rows for class members
+    #
+    def initialize(cls, subclasses = {}, cache = {})
       @cls = cls
       @subclasses = subclasses
+      @cache = cache
       @formatter = DocFormatter.new(cls.full_name)
     end
 
@@ -23,10 +30,10 @@ module JsDuck
        abstract,
        description,
        "<div class='hr'></div>",
-       CfgTable.new(@cls).to_html,
-       PropertyTable.new(@cls).to_html,
-       MethodTable.new(@cls).to_html,
-       EventTable.new(@cls).to_html,
+       CfgTable.new(@cls, @cache).to_html,
+       PropertyTable.new(@cls, @cache).to_html,
+       MethodTable.new(@cls, @cache).to_html,
+       EventTable.new(@cls, @cache).to_html,
        "</div>",
       ].join("\n")
     end

data/lib/jsduck/parser.rb

@@ -1,18 +1,20 @@
 require 'jsduck/lexer'
+require 'jsduck/doc_parser'
 
 module JsDuck
 
   class Parser
     def initialize(input)
       @lex = Lexer.new(input)
+      @doc_parser = DocParser.new
       @docs = []
     end
 
     # Parses the whole JavaScript block and returns array where for
     # each doc-comment there is a hash of three values: the comment
-    # itself as string, number of the line where the comment starts,
-    # and parsed structure of the code that immediately follows the
-    # comment.
+    # structure created by DocParser, number of the line where the
+    # comment starts, and parsed structure of the code that
+    # immediately follows the comment.
     #
     # For example with the following JavaScript input:
     #
@@ -26,7 +28,10 @@ module JsDuck
     #
     # [
     #   {
-    #     :comment => "/**\n * @param {String} foo\n */",
+    #     :comment => [
+    #       {:tagname => :default, :doc => "Method description"},
+    #       {:tagname => :return, :type => "Number", :doc => ""},
+    #     ],
     #     :linenr => 1,
     #     :code => {
     #       :type => :assignment,
@@ -45,10 +50,10 @@ module JsDuck
     #
     def parse
       while !@lex.empty? do
-        if look(:doc_comment) then
+        if look(:doc_comment)
           comment = @lex.next(true)
           @docs << {
-            :comment => comment[:value],
+            :comment => @doc_parser.parse(comment[:value]),
             :linenr => comment[:linenr],
             :code => code_block
           }
@@ -64,15 +69,18 @@ module JsDuck
 
     # <code-block> := <function> | <var-declaration> | <assignment> | <property-literal>
     def code_block
-      if look("function") then
+      if look("function")
         function
-      elsif look("var") then
+      elsif look("var")
         var_declaration
-      elsif look(:ident, ":") || look(:string, ":") then
+      elsif look(:ident, ":") || look(:string, ":")
         property_literal
-      elsif look(:ident) || look("this") then
+      elsif look(",", :ident, ":") || look(",", :string, ":")
+        match(",")
+        property_literal
+      elsif look(:ident) || look("this")
         maybe_assignment
-      elsif look(:string) then
+      elsif look(:string)
         {:type => :assignment, :left => [match(:string)]}
       else
         {:type => :nop}
@@ -115,7 +123,7 @@ module JsDuck
     # <maybe-assignment> := <ident-chain> [ "=" <expression> ]
     def maybe_assignment
       left = ident_chain
-      if look("=") then
+      if look("=")
         match("=")
         right = expression
       end
@@ -143,17 +151,17 @@ module JsDuck
     # <expression> := <function> | <ext-extend> | <literal>
     # <literal> := <string> | <boolean> | <number> | <regex>
     def expression
-      if look("function") then
+      if look("function")
         function
-      elsif look("Ext", ".", "extend") then
+      elsif look("Ext", ".", "extend")
         ext_extend
-      elsif look(:string) then
+      elsif look(:string)
         {:type => :literal, :class => "String"}
-      elsif look("true") || look("false") then
+      elsif look("true") || look("false")
         {:type => :literal, :class => "Boolean"}
-      elsif look(:number) then
+      elsif look(:number)
         {:type => :literal, :class => "Number"}
-      elsif look(:regex) then
+      elsif look(:regex)
         {:type => :literal, :class => "RegExp"}
       end
     end
@@ -182,7 +190,7 @@ module JsDuck
     # Matches all arguments, returns the value of last match
     # When the whole sequence doesn't match, throws exception
     def match(*args)
-      if look(*args) then
+      if look(*args)
         last = nil
         args.length.times { last = @lex.next }
         last

data/lib/jsduck/property_table.rb

@@ -3,8 +3,8 @@ require 'jsduck/table'
 module JsDuck
 
   class PropertyTable < Table
-    def initialize(cls)
-      super(cls)
+    def initialize(cls, cache={})
+      super(cls, cache)
       @type = :property
       @id = @cls.full_name + "-props"
       @title = "Public Properties"

data/lib/jsduck/table.rb

@@ -8,8 +8,18 @@ module JsDuck
   # @row_class, and implement the signature_suffix() and extra_doc()
   # methods.
   class Table
-    def initialize(cls)
+    # Initializes class member table generator
+    #
+    # - cls : the class for which to generate the table.
+    #
+    # - cache : shared cache of already generated HTML rows.  If Foo
+    #   inherits from Bar and we have already generated members table
+    #   for Bar, then we don't have to re-render all the HTML the
+    #   methods from Bar, but can just look them up from cache.
+    #
+    def initialize(cls, cache={})
       @cls = cls
+      @cache = cache
       @formatter = DocFormatter.new(cls.full_name)
     end
 
@@ -29,20 +39,39 @@ module JsDuck
       ].join("\n")
     end
 
+    # Returns HTML row for class member.
+    #
+    # When HTML for member has already been rendered we can pick it
+    # from cache and only fill in some details which differ from class
+    # to class.
+    #
+    # Otherwise perform the rendering of HTML and save it to cache.
     def row(item)
+      cache_key = "#{item[:member]}-#{@row_class}-#{item[:name]}"
+      if @cache[cache_key]
+        html = @cache[cache_key]
+      else
+        html = @cache[cache_key] = create_row(item)
+      end
+      inherited = inherited?(item) ? 'inherited' : ''
+      owner = inherited?(item) ? member_link(item) : Class.short_name(item[:member])
+      html.sub(/!!--inherited--!!/, inherited).sub(/!!--owner-class--!!/, owner)
+    end
+
+    # Generates HTML for the row, leaving in placeholders for owner
+    # class name and inherited class.
+    def create_row(item)
       p_doc = primary_doc(item)
       e_doc = extra_doc(item)
       description = expandable_desc(p_doc, e_doc)
       expandable = expandable?(p_doc, e_doc) ? 'expandable' : ''
-      inherited = inherited?(item) ? 'inherited' : ''
-      source = inherited?(item) ? member_link(item) : Class.short_name(item[:member])
-      [
-       "<tr class='#{@row_class} #{expandable} #{inherited}'>",
-         "<td class='micon'><a href='#expand' class='exi'>&nbsp;</a></td>",
-         "<td class='sig'>#{signature(item)}<div class='mdesc'>#{description}</div></td>",
-         "<td class='msource'>#{source}</td>",
-       "</tr>",
-      ].join("")
+      return <<-EOHTML
+      <tr class='#{@row_class} #{expandable} !!--inherited--!!'>
+        <td class='micon'><a href='#expand' class='exi'>&nbsp;</a></td>
+        <td class='sig'>#{signature(item)}<div class='mdesc'>#{description}</div></td>
+        <td class='msource'>!!--owner-class--!!</td>
+      </tr>
+      EOHTML
     end
 
     def member_link(item)

data/lib/jsduck/timer.rb

@@ -0,0 +1,40 @@
+module JsDuck
+
+  # Helper for timing execution of named code blocks.
+  #
+  #     timer = Timer.new
+  #     a = timer.time(:sum) { 5 + 5 }
+  #     b = timer.time(:sum) { 5 + 5 }
+  #     c = timer.time(:mult) { 5 * 5 }
+  #     d = timer.time(:mult) { 5 * 5 }
+  #     timer.report
+  #
+  # The #report method will print sum of the time spent in each
+  # category.
+  #
+  class Timer
+    def initialize
+      @timings = {}
+    end
+
+    # Performs timing of one code block.
+    # Returns the same value that code block returns.
+    def time(name)
+      begin_time = Time.now
+      result = yield
+      interval = Time.now - begin_time
+      if @timings[name]
+        @timings[name] += interval
+      else
+        @timings[name] = interval
+      end
+      result
+    end
+
+    # prints timings report to console
+    def report
+      @timings.each {|name, time| puts "#{name}:\t#{time} seconds" }
+    end
+  end
+
+end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: jsduck
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 0
-  - 2
-  version: "0.2"
+  - 3
+  version: "0.3"
 platform: ruby
 authors: 
 - Rene Saarsoo
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-10 00:00:00 +02:00
+date: 2011-02-08 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,6 +45,20 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: parallel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
 description: Better ext-doc like JavaScript documentation generator for ExtJS
 email: nene@triin.net
 executables: 
@@ -79,6 +93,7 @@ files:
 - lib/jsduck/source_formatter.rb
 - lib/jsduck/subclasses.rb
 - lib/jsduck/table.rb
+- lib/jsduck/timer.rb
 - lib/jsduck/tree.rb
 - lib/jsduck/tree_icons.rb
 - template/index.html