jsduck 4.0.1 → 4.1.1

data/lib/jsduck/source_file.rb

@@ -1,97 +0,0 @@
-require 'jsduck/source_file_parser'
-require 'jsduck/html'
-
-module JsDuck
-
-  # Represents one JavaScript or CSS source file.
-  #
-  # The filename parameter determines whether it's parsed as
-  # JavaScript (the default) or CSS.
-  class SourceFile
-    attr_reader :filename
-    attr_reader :contents
-    attr_reader :docs
-    attr_reader :html_filename
-
-    def initialize(contents, filename="", options={})
-      @contents = contents
-      @filename = filename
-      @html_filename = ""
-      @links = {}
-
-      @docs = SourceFileParser.new.parse(@contents, @filename, options)
-
-      @docs.map do |docset|
-        link(docset[:linenr], docset)
-      end
-    end
-
-    # loops through each doc-object in file
-    def each(&block)
-      @docs.each(&block)
-    end
-
-    # Sets the html filename of this file,
-    # updating also all doc-objects linking this file
-    def html_filename=(html_filename)
-      @html_filename = html_filename
-      @links.each_value do |line|
-        line.each do |link|
-          link[:file][:html_filename] = @html_filename
-          link[:file][:href] = @html_filename + "#" + id(link[:doc])
-        end
-      end
-    end
-
-    # Returns source code as HTML with lines starting doc-comments specially marked.
-    def to_html
-      linenr = 0
-      lines = []
-      # Use #each_line instead of #lines to support Ruby 1.6
-      @contents.each_line do |line|
-        linenr += 1;
-        line = HTML.escape(line)
-        # wrap the line in as many spans as there are links to this line number.
-        if @links[linenr]
-          @links[linenr].each do |link|
-            line = "<span id='#{id(link[:doc])}'>#{line}</span>"
-          end
-        end
-        lines << line
-      end
-      lines.join()
-    end
-
-    def id(doc)
-      if doc[:tagname] == :class
-        doc[:name].gsub(/\./, '-')
-      else
-        # when creation of global class is skipped,
-        # this owner property can be nil.
-        (doc[:owner] || "global").gsub(/\./, '-') + "-" + doc[:id]
-      end
-    end
-
-    private
-
-    # Creates two-way link between sourcefile and doc-object.
-    # If doc-object is class, links also the contained cfgs and constructor.
-    # Returns the modified doc-object after done.
-    def link(linenr, doc)
-      @links[linenr] = [] unless @links[linenr]
-      file = {
-        :filename => @filename,
-        :linenr => linenr,
-      }
-      @links[linenr] << {:doc => doc, :file => file}
-      doc[:files] = [file]
-      if doc[:tagname] == :class
-        doc[:members][:cfg].each {|cfg| link(linenr, cfg) }
-        doc[:members][:method].each {|method| link(linenr, method) }
-      end
-      doc
-    end
-
-  end
-
-end

data/lib/jsduck/source_file_parser.rb

@@ -1,70 +0,0 @@
-require 'jsduck/js_parser'
-require 'jsduck/css_parser'
-require 'jsduck/doc_parser'
-require 'jsduck/merger'
-require 'jsduck/ast'
-require 'jsduck/doc_type'
-require 'jsduck/doc_ast'
-require 'jsduck/class_doc_expander'
-
-module JsDuck
-
-  # Performs the actual parsing of CSS or JS source.
-  #
-  # This is the class that brings together all the different steps of
-  # parsing the source.
-  class SourceFileParser
-
-    def initialize
-      @doc_type = DocType.new
-      @doc_parser = DocParser.new
-      @class_doc_expander = ClassDocExpander.new
-      @doc_ast = DocAst.new
-      @merger = Merger.new
-    end
-
-    # Parses file into final docset that can be fed into Aggregator
-    def parse(contents, filename="", options={})
-      @doc_ast.filename = filename
-
-      parse_js_or_css(contents, filename, options).map do |docset|
-        expand(docset)
-      end.flatten.map do |docset|
-        merge(docset)
-      end
-    end
-
-    private
-
-    # Parses the file depending on filename as JS or CSS
-    def parse_js_or_css(contents, filename, options)
-      if filename =~ /\.s?css$/
-        docs = CssParser.new(contents, options).parse
-      else
-        docs = JsParser.new(contents, options).parse
-        docs = Ast.new(docs, options).detect_all!
-      end
-    end
-
-    # Parses the docs, detects tagname and expands class docset
-    def expand(docset)
-      docset[:comment] = @doc_parser.parse(docset[:comment])
-      docset[:tagname] = @doc_type.detect(docset[:comment], docset[:code])
-
-      if docset[:tagname] == :class
-        @class_doc_expander.expand(docset)
-      else
-        docset
-      end
-    end
-
-    # Merges comment and code parts of docset
-    def merge(docset)
-      @doc_ast.linenr = docset[:linenr]
-      docset[:comment] = @doc_ast.detect(docset[:tagname], docset[:comment])
-
-      @merger.merge(docset)
-    end
-  end
-
-end

data/lib/jsduck/source_writer.rb

@@ -1,87 +0,0 @@
-require 'jsduck/logger'
-require 'jsduck/parallel_wrap'
-require 'fileutils'
-
-module JsDuck
-
-  # Writes HTML JavaScript/CSS source into HTML files.
-  class SourceWriter
-    def initialize(source_files)
-      @source_files = source_files
-    end
-
-    # Writes all source files as HTML files into destination dir.
-    def write(destination)
-      generate_html_filenames
-
-      FileUtils.mkdir(destination)
-      ParallelWrap.each(@source_files) do |file|
-        Logger.instance.log("Writing source", file.html_filename)
-        write_single(destination + "/" + file.html_filename, file.to_html)
-      end
-    end
-
-    private
-
-    # Generates unique HTML filenames for each file.
-    #
-    # Can't be done in parallel for obvious reasons, but also
-    # because file.html_filename= method updates all the doc-objects
-    # related to the file.
-    def generate_html_filenames
-      filenames = {}
-      @source_files.each do |file|
-        i = 0
-        begin
-          name = html_filename(file.filename, i)
-          ci_name = name.downcase # case insensitive name
-          i += 1
-        end while filenames.has_key?(ci_name)
-        filenames[ci_name] = true
-        file.html_filename = name
-      end
-    end
-
-    # Returns HTML filename for n'th file with given name.
-    #
-    # html_filename("Foo.js", 0) => "Foo.html"
-    # html_filename("Foo.js", 1) => "Foo2.html"
-    # html_filename("Foo.js", 2) => "Foo3.html"
-    #
-    def html_filename(filename, nr=0)
-      File.basename(filename, ".js") + (nr > 0 ? (nr+1).to_s : "") + ".html"
-    end
-
-    def write_single(filename, source)
-      File.open(filename, 'w') {|f| f.write(wrap_page(source)) }
-    end
-
-    # Returns source wrapped inside HTML page
-    def wrap_page(source)
-      return <<-EOHTML
-<!DOCTYPE html>
-<html>
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  <title>The source code</title>
-  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
-  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
-  <style type="text/css">
-    .highlight { display: block; background-color: #ddd; }
-  </style>
-  <script type="text/javascript">
-    function highlight() {
-      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
-    }
-  </script>
-</head>
-<body onload="prettyPrint(); highlight();">
-  <pre class="prettyprint lang-js">#{source}</pre>
-</body>
-</html>
-      EOHTML
-    end
-
-  end
-
-end

data/lib/jsduck/stats.rb

@@ -1,103 +0,0 @@
-
-module JsDuck
-
-  # Calculates all kinds of statistics for classes
-  class Stats
-    # Maps array of classes into array of stats per class
-    def create(classes)
-      @classes = classes
-
-      classes.map do |cls|
-        local_members = cls.all_local_members
-        total_members = cls.all_members
-        class_wc = wc(cls[:doc])
-        members_wc = members_wc(cls)
-
-        {
-          :name => cls[:name],
-
-          :local_cfgs => member_count(local_members, :cfg),
-          :local_properties => member_count(local_members, :property),
-          :local_methods => member_count(local_members, :method),
-          :local_events => member_count(local_members, :event),
-          :local_members => local_members.length,
-
-          :total_cfgs => member_count(total_members, :cfg),
-          :total_properties => member_count(total_members, :property),
-          :total_methods => member_count(total_members, :method),
-          :total_events => member_count(total_members, :event),
-          :total_members => total_members.length,
-
-          :fanIn => fan_in(cls),
-          :fanOut => fan_out(cls),
-
-          :class_wc => class_wc,
-          :members_wc => members_wc,
-          :wc_per_member => local_members.length > 0 ? (members_wc / local_members.length) : 0,
-        }
-      end
-    end
-
-    def member_count(members, type)
-      members.find_all {|m| m[:tagname] == type }.length
-    end
-
-    # How many classes depend on this class
-    def fan_in(cls)
-      fan_in_table[cls[:name]] || 0
-    end
-
-    # On how many classes this class depends on
-    def fan_out(cls)
-      dependencies(cls).length
-    end
-
-    # list of class names the class depends on
-    def dependencies(cls)
-      [
-        cls[:extends],
-        cls[:mixins],
-        cls[:requires],
-        cls[:uses],
-      ].compact.flatten.sort.uniq
-    end
-
-    # Returns map of class names to its fan-in number.
-    def fan_in_table
-      return @fi_table if @fi_table
-
-      @fi_table = {}
-      @classes.each do |cls|
-        dependencies(cls).each do |d|
-          @fi_table[d] = (@fi_table[d] || 0) + 1
-        end
-      end
-      @fi_table
-    end
-
-    # Counts nr of words in documentation of all members of class
-    def members_wc(cls)
-      cnt = 0
-      cls.all_local_members.each do |m|
-        cnt += wc(m[:doc])
-        (m[:params] || []).each {|p| cnt += property_wc(p) }
-        (m[:properties] || []).each {|p| cnt += property_wc(p) }
-        cnt += wc(m[:return][:doc]) if m[:return]
-      end
-      cnt
-    end
-
-    def property_wc(property)
-      cnt = wc(property[:doc] || "")
-      (property[:properties] || []).each {|p| cnt += property_wc(p) }
-      cnt
-    end
-
-    # Strips HTML and counts words in text
-    def wc(str)
-      str.gsub(/<\/?[^>]*>/, "").scan(/\w+/).length
-    end
-
-  end
-
-end

data/lib/jsduck/stdout.rb

@@ -1,31 +0,0 @@
-require 'jsduck/json_duck'
-require 'singleton'
-
-module JsDuck
-
-  # Central place for buffering JSON data that's meant to be written to STDOUT
-  class Stdout
-    include Singleton
-
-    def initialize
-      @data = nil
-    end
-
-    # Adds array of new data
-    def add(data)
-      if @data
-        @data += data
-      else
-        @data = data
-      end
-    end
-
-    # Writes data to STDOUT in JSON format,
-    # but only if some data was added.
-    def flush
-      puts JsonDuck.generate(@data) if @data
-    end
-
-  end
-
-end