class JsDuck::ClassDocExpander

Expands class docset into one or more docsets.

The resulting list can contain the following:

Public Instance Methods

expand(docset) click to toggle source

Expands class-docset into multiple docsets.

# File lib/jsduck/class_doc_expander.rb, line 17
def expand(docset)
  @constructor_found = false

  expand_comment(docset) + expand_code(docset)
end

Private Instance Methods

code_to_docset(m) click to toggle source
# File lib/jsduck/class_doc_expander.rb, line 120
def code_to_docset(m)
  return {
    :tagname => m[:tagname],
    :type => :no_comment,
    :comment => [],
    :code => m,
    :linenr => m[:linenr],
  }
end
expand_code(docset) click to toggle source

Turns auto-detected class members into docsets in their own right.

# File lib/jsduck/class_doc_expander.rb, line 108
def expand_code(docset)
  results = []

  if docset[:code]
    (docset[:code][:members] || []).each do |m|
      results << code_to_docset(m) unless @constructor_found && JsDuck::Class.constructor?(m)
    end
  end

  results
end
expand_comment(docset) click to toggle source

Handles old syntax where configs and constructor are part of class doc-comment.

Gathers all tags until first @cfg or @constructor into the first bare :class group. We have a special case for @xtype which in ExtJS comments often appears after @constructor - so we explicitly place it into :class group.

Then gathers each @cfg and tags following it into :cfg group, so that it becomes array of arrays of tags. This is to allow some configs to be marked with @private or whatever else.

Finally gathers tags after @constructor into its group.

# File lib/jsduck/class_doc_expander.rb, line 38
def expand_comment(docset)
  groups = {
    :class => [],
    :cfg => [],
    :constructor => [],
  }

  # By default everything goes to :class group
  group_name = :class

  docset[:comment].each do |tag|
    tagname = tag[:tagname]

    if tagname == :cfg || tagname == :constructor
      group_name = tagname
      if tagname == :cfg && (tag[:name] !~ /\./ || groups[:cfg].length == 0)
        groups[:cfg] << []
      end
    end

    if tagname == :aliases
      # For backwards compatibility allow @xtype after @constructor
      groups[:class] << tag
    elsif group_name == :cfg
      groups[:cfg].last << tag
    else
      groups[group_name] << tag
    end
  end

  groups_to_docsets(groups, docset)
end
groups_to_docsets(groups, docset) click to toggle source

Turns groups hash into list of docsets

# File lib/jsduck/class_doc_expander.rb, line 72
def groups_to_docsets(groups, docset)
  results = []
  results << {
    :tagname => :class,
    :type => docset[:type],
    :comment => groups[:class],
    :code => docset[:code],
    :linenr => docset[:linenr],
  }
  groups[:cfg].each do |cfg|
    results << {
      :tagname => :cfg,
      :type => docset[:type],
      :comment => cfg,
      :code => {},
      :linenr => docset[:linenr],
    }
  end
  if groups[:constructor].length > 0
    # Remember that a constructor is already found and ignore if a
    # constructor is detected from code.
    @constructor_found = true

    results << {
      :tagname => :method,
      :type => docset[:type],
      :comment => groups[:constructor],
      :code => {},
      :linenr => docset[:linenr],
    }
  end
  results
end