class DocContext
special AbstractCompiler
# Destination directory
- readable writable attr _dir: String = "."
+ readable writable var _dir: String = "."
# Content of a generated file
- attr _stage_context: StageContext = new StageContext(null)
+ var _stage_context: StageContext = new StageContext(null)
# Add a string in the content
- meth add(s: String) do
+ fun add(s: String) do
_stage_context.content.add(s)
_stage_context.validate = true
end
# Add a string in the content iff some other string are added
- meth stage(s: String) do _stage_context.content.add(s)
+ fun stage(s: String) do _stage_context.content.add(s)
# Create a new stage in the content
- meth open_stage do _stage_context = new StageContext(_stage_context)
+ fun open_stage do _stage_context = new StageContext(_stage_context)
# Close the current stage in the content
- meth close_stage
+ fun close_stage
do
var s = _stage_context.parent
if _stage_context.validate then
end
# Write the content to a new file
- meth write_to(filename: String)
+ fun write_to(filename: String)
do
- print "Generate {filename}"
var f = new OFStream.open(filename)
for s in _stage_context.content do
f.write(s)
end
# Currently computed module
- readable attr _module: nullable MMSrcModule
+ readable var _module: nullable MMSrcModule
# Is the current directory module computed as a simple modude ?
- readable writable attr _inside_mode: Bool = false
+ readable writable var _inside_mode: Bool = false
# Is the current module computed as a intruded one ?
- readable writable attr _intrude_mode: Bool = false
+ readable writable var _intrude_mode: Bool = false
# Compued introducing entities (for the index)
- attr _entities: Array[MMEntity] = new Array[MMEntity]
+ var _entities: Array[MMEntity] = new Array[MMEntity]
# Register an entity (for the index)
- meth register(e: MMEntity)
+ fun register(e: MMEntity)
do
_entities.add(e)
if e isa MMSrcModule then
end
# Start a new file
- meth clear
+ fun clear
do
_stage_context = new StageContext(null)
end
# Generate common files (frames, index, overview)
- meth extract_other_doc
+ fun extract_other_doc
do
+ info("Generating other files",1)
_module = null
inside_mode = false
intrude_mode = false
write_to("{dir}/index.html")
end
- meth add_header(title: String)
+ fun add_header(title: String)
do
add("<html><head><title>{title}</title></head>\n<body>\n")
add("<table border=\"0\" width=\"100%\" cellpadding=\"1\" cellspacing=\"0\"><tr><td bgcolor=\"#eeeeff\">\n")
add("<a href=\"overview.html\"><b>Overview</b></a> <a href=\"index-1.html\"><b>Index</b></a> <a href=\"index.html\" target=\"_top\"><b>With Frames</b></a>\n")
add("</td></tr></table>")
add("Visibility: ")
+ var module = module
if (not inside_mode and not intrude_mode) or module == null then
add("<b>Public</b> ")
else
end
# Sorter of entities in alphabetical order
- attr _sorter: AlphaSorter[MMEntity] = new AlphaSorter[MMEntity]
+ var _sorter: AlphaSorter[MMEntity] = new AlphaSorter[MMEntity]
# Sort entities in the alphabetical order
- meth sort(array: Array[MMEntity])
+ fun sort(array: Array[MMEntity])
do
_sorter.sort(array)
end
- readable writable attr _owned_modules: Array[MMModule] = new Array[MMModule]
+ readable writable var _owned_modules: Array[MMModule] = new Array[MMModule]
# Return the known_owner for current module
# if inside_mode is set, it could be a different result
- meth known_owner_of(m: MMModule): MMModule
+ fun known_owner_of(m: MMModule): MMModule
do
var module = module
if module == null then return m
end
end
- readable attr _opt_dir: OptionString = new OptionString("Directory where doc is generated", "-d", "--dir")
+ readable var _opt_dir: OptionString = new OptionString("Directory where doc is generated", "-d", "--dir")
- redef meth perform_work(mods)
+ redef fun perform_work(mods)
do
dir.mkdir
init
do
+ keep_ast = true
super("nitdoc")
option_context.add_option(opt_dir)
end
- redef meth process_options
+ redef fun process_options
do
super
var d = opt_dir.value
# Conditionnal part of the text content of a DocContext
class StageContext
# Content of the current stage
- readable attr _content: Array[String] = new Array[String]
+ readable var _content: Array[String] = new Array[String]
# Is a normal string already added?
- readable writable attr _validate: Bool = false
+ readable writable var _validate: Bool = false
# Parent stage is any
- readable attr _parent: nullable StageContext = null
+ readable var _parent: nullable StageContext = null
init(parent: nullable StageContext) do _parent = parent
end
# Efficiently sort object with their to_s method
class AlphaSorter[E: Object]
special AbstractSorter[E]
- redef meth compare(a, b)
+ redef fun compare(a, b)
do
var sa: String
var sb: String
end
# Keep track of to_s values
- attr _dico: HashMap[Object, String] = new HashMap[Object, String]
+ var _dico: HashMap[Object, String] = new HashMap[Object, String]
init do end
end
# Generalization of metamodel entities
class MMEntity
# Return a link to
- meth html_link(dctx: DocContext): String is abstract
+ fun html_link(dctx: DocContext): String is abstract
# Is the entity should appear in the generaed doc
- meth need_doc(dctx: DocContext): Bool is abstract
+ fun need_doc(dctx: DocContext): Bool is abstract
# Return a one liner description
- meth short_doc: String do return " "
+ fun short_doc: String do return " "
# The doc node from the AST
# Return null is none
- meth doc: nullable ADoc do return null
+ fun doc: nullable ADoc do return null
# Human redable location of the entity (module/class/property)
- meth locate(dctx: DocContext): String do return ""
+ fun locate(dctx: DocContext): String do return ""
# Part of the prototype before the name (kind, modifiers, qualifier)
- meth prototype_head(dctx: DocContext): String is abstract
+ fun prototype_head(dctx: DocContext): String is abstract
# Part of the property after the name (signature, modifiers)
- meth prototype_body(dctx: DocContext): String do return ""
+ fun prototype_body(dctx: DocContext): String do return ""
end
redef class MMModule
special MMEntity
- redef meth html_link(dctx) do
+ redef fun html_link(dctx) do
if dctx.module == self then
return "{self}"
else
return "<a href=\"{self}.html\">{self}</a>"
end
end
- redef meth need_doc(dctx) do return true
- redef meth prototype_head(dctx) do return "module "
+ redef fun need_doc(dctx) do return true
+ redef fun prototype_head(dctx) do return "module "
+
+ var _known_owner_of_cache: Map[MMModule, MMModule] = new HashMap[MMModule, MMModule]
- attr _known_owner_of_cache: Map[MMModule, MMModule] = new HashMap[MMModule, MMModule]
- meth known_owner_of(module: MMModule): MMModule
- do
+ # Return the owner of `module` from the point of view of `self`
+ fun known_owner_of(module: MMModule): MMModule
+ do
if _known_owner_of_cache.has_key(module) then return _known_owner_of_cache[module]
var res = module
- if mhe < module and visibility_for(module) != 0 then
+ # is module is publicly imported by self?
+ if mhe < module and visibility_for(module) != 0 then
res = known_owner_of_intern(module, self, false)
else
+ # Return the canonnical owner of module from the point of view of self
res = module.owner(self)
end
_known_owner_of_cache[module] = res
end
# Return the most general module that own self
- meth owner(from: MMModule): MMModule
+ fun owner(from: MMModule): MMModule
do
var res = self
var d: nullable MMDirectory = directory
return res
end
- private meth known_owner_of_intern(module: MMModule, from: MMModule, as_owner: Bool): MMModule
+ # ???
+ private fun known_owner_of_intern(module: MMModule, from: MMModule, as_owner: Bool): MMModule
do
if module == self then return self
var candidates = new Array[MMModule]
if not m.mhe <= module then continue
candidates.add(m.known_owner_of_intern(module, from, true))
end
- assert not candidates.is_empty
+ # FIXME: I do not know what this does
+ if candidates.is_empty then return module.owner(from)
var max = candidates.first
for m in candidates do
if max.mhe < m then max = m
redef class MMLocalProperty
special MMEntity
# Anchor of the property description in the module html file
- meth html_anchor: String
+ fun html_anchor: String
do
return "PROP_{local_class}_{cmangle(name)}"
end
- redef meth html_link(dctx)
+ redef fun html_link(dctx)
do
var m = module
if not need_doc(dctx) then m = global.intro.module
- var m = dctx.known_owner_of(m)
+ m = dctx.known_owner_of(m)
if m == dctx.module then
return "<a href=\"#{html_anchor}\">{self}</a>"
else
end
end
- # Kind of property (meth, attr, etc.)
- meth kind: String is abstract
+ # Kind of property (fun, attr, etc.)
+ fun kind: String is abstract
- redef meth locate(dctx)
+ redef fun locate(dctx)
do
return "in {module.html_link(dctx)}::{local_class.html_link(dctx)}"
end
- meth known_intro_class(dctx: DocContext): MMLocalClass
+ fun known_intro_class(dctx: DocContext): MMLocalClass
do
var mod = dctx.known_owner_of(global.intro.local_class.module)
var cla = mod[global.intro.local_class.global]
return cla
end
- redef meth prototype_head(dctx)
+ redef fun prototype_head(dctx)
do
var res = new Buffer
var intro_class = known_intro_class(dctx)
return res.to_s
end
- redef meth prototype_body(dctx)
+ redef fun prototype_body(dctx)
do
var res = new Buffer
- res.append(signature.to_html(dctx))
+ res.append(signature.to_html(dctx, true))
var s = self
- if s.node != null then
- if s.node isa ADeferredMethPropdef then
+ if s isa MMMethod then
+ if s.is_abstract then
res.append(" is abstract")
- else if s.node isa AInternMethPropdef then
+ else if s.is_intern then
res.append(" is intern")
end
end
return res.to_s
end
- redef meth need_doc(dctx)
+ redef fun need_doc(dctx)
do
if global.visibility_level >= 3 or self isa MMAttribute then
if not dctx.intrude_mode then return false
return doc != null
end
- redef meth short_doc
+ redef fun short_doc
do
var d = doc
if d != null then
end
end
- redef meth doc
+ redef fun doc
do
var n = node
- if n == null or not node isa PPropdef then
+ if n == null or not n isa APropdef then
return null
end
- assert n isa PPropdef
var d = n.n_doc
if d == null then
return null
end
- assert d isa ADoc
if d.n_comment.is_empty then
return null
else
end
end
redef class MMMethod
- redef meth kind do return if global.is_init then "init" else "meth"
+ redef fun kind do return if global.is_init then "init" else "fun"
end
redef class MMAttribute
- redef meth kind do return "attr"
+ redef fun kind do return "var"
end
redef class MMTypeProperty
- redef meth kind do return "type"
+ redef fun kind do return "type"
end
redef class MMSrcModule
# Extract and generate html file for the module
- meth extract_module_doc(dctx: DocContext)
+ fun extract_module_doc(dctx: DocContext)
do
+ dctx.info("Generating HTML for module {name}",1)
dctx.register(self)
dctx.clear
end
end
- meth extract_module_doc_inside(dctx: DocContext)
+ fun extract_module_doc_inside(dctx: DocContext)
do
dctx.add_header("Module {self}")
dctx.add("<h1>Module {self}</h1>\n<dl>")
var s = ""
var d: nullable MMDirectory = directory
- while d == null do
+ while d != null do
if d.owner != null and (d.owner != self or dctx.inside_mode or dctx.intrude_mode) then
s = "{d.owner.html_link(dctx)}::{s}"
end
dctx.add("</body></html>\n")
end
- redef meth short_doc
+ redef fun short_doc
do
var d = doc
if d != null then
end
end
- redef meth doc
+ redef fun doc
do
var n = node
if n.n_packagedecl == null then
return null
end
var np = n.n_packagedecl
- assert np isa APackagedecl
var d = np.n_doc
if d == null then
return null
end
- assert d isa ADoc
if d.n_comment.is_empty then
return null
else
redef class ADoc
# Html transcription of the doc
- meth to_html: String
+ fun to_html: String
do
var res = new Buffer
for c in n_comment do
end
# Oneliner transcription of the doc
- meth short: String
+ fun short: String
do
return n_comment.first.text.substring_from(1)
end
redef class MMLocalClass
special MMEntity
# Anchor of the class description in the module html file
- meth html_anchor: String do return "CLASS_{self}"
+ fun html_anchor: String do return "CLASS_{self}"
- redef meth html_link(dctx)
+ redef fun html_link(dctx)
do
var m = module
if not need_doc(dctx) then m = global.module
- var m = dctx.known_owner_of(m)
+ m = dctx.known_owner_of(m)
if m == dctx.module then
return "<a href=\"#{html_anchor}\">{self}</a>"
else
end
end
- redef meth short_doc do return global.intro.short_doc
+ redef fun short_doc do return global.intro.short_doc
- redef meth doc do return global.intro.doc
+ redef fun doc do return global.intro.doc
- redef meth need_doc(dctx) do
+ redef fun need_doc(dctx) do
if module == dctx.module then
for m in dctx.owned_modules do
if m.global_classes.has(global) then
return false
end
- redef meth locate(dctx) do return "in {module.html_link(dctx)}"
+ redef fun locate(dctx) do return "in {module.html_link(dctx)}"
- meth known_intro(dctx: DocContext): MMLocalClass do return dctx.known_owner_of(global.intro.module)[global]
+ fun known_intro(dctx: DocContext): MMLocalClass do return dctx.known_owner_of(global.intro.module)[global]
- redef meth prototype_head(dctx)
+ redef fun prototype_head(dctx)
do
var res = new Buffer
var ki = known_intro(dctx)
return res.to_s
end
- redef meth prototype_body(dctx)
+ redef fun prototype_body(dctx)
do
var res = new Buffer
if arity > 0 then
end
# Extract the doc of a class
- meth extract_class_doc(dctx: DocContext)
+ fun extract_class_doc(dctx: DocContext)
do
dctx.add("<a name=\"{html_anchor}\"></a><h2>{self}</h2><small>{module.html_link(dctx)}::</small><br/>{prototype_head(dctx)}<b>{self}</b>{prototype_body(dctx)}\n")
dctx.add("<blockquote>\n")
dctx.add("</blockquote><hr/>\n")
end
- meth pass_name(pass: Int): String
+ fun pass_name(pass: Int): String
do
var names = once ["Virtual Types", "Consructors", "Methods", "Attributes"]
return names[pass]
end
- meth accept_prop(p: MMLocalProperty, pass: Int): Bool
+ fun accept_prop(p: MMLocalProperty, pass: Int): Bool
do
if pass == 0 then
return p isa MMTypeProperty
abort
end
- meth property_summary(dctx: DocContext, pass: Int): Array[MMLocalProperty]
+ fun property_summary(dctx: DocContext, pass: Int): Array[MMLocalProperty]
do
var passname = pass_name(pass)
dctx.open_stage
# skip pass 1 because constructors are not inherited
var cmap = new HashMap[MMLocalClass, Array[MMLocalProperty]]
var mmap = new HashMap[MMModule, Array[MMLocalProperty]]
- var props = new Array[MMLocalClass]
for c in che.greaters do
if c isa MMSrcLocalClass then
var km = dctx.known_owner_of(c.module)
end
var mmap = new HashMap[MMModule, Array[MMLocalProperty]]
- var props = new Array[MMLocalClass]
for c in crhe.order do
if module.mhe <= c.module or dctx.owned_modules.has(c.module) or not c isa MMSrcLocalClass then continue
var km = dctx.known_owner_of(c.module)
return new_props
end
- meth property_detail(dctx: DocContext, pass: Int, new_props: Array[MMLocalProperty])
+ fun property_detail(dctx: DocContext, pass: Int, new_props: Array[MMLocalProperty])
do
var passname = pass_name(pass)
dctx.open_stage
end
# Add rows for properties inheriterd to some heirs
- meth properties_inherited_from(dctx: DocContext, heir: MMLocalClass, pass: Int)
+ fun properties_inherited_from(dctx: DocContext, heir: MMLocalClass, pass: Int)
do
var properties = new Array[String]
for g in global_properties do
end
redef class MMSrcLocalClass
- redef meth short_doc
+ redef fun short_doc
do
var d = doc
if d != null then
end
end
- redef meth doc
+ redef fun doc
do
- var n = nodes.first
- if not n isa AClassdef then
+ var n = node
+ if not n isa AStdClassdef then
return null
end
- assert n isa AClassdef
var d = n.n_doc
if d == null then
return null
end
- assert d isa ADoc
if d.n_comment.is_empty then
return null
else
end
end
- redef meth need_doc(dctx)
+ redef fun need_doc(dctx)
do
if global.visibility_level >= 3 then
if not dctx.intrude_mode then return false
redef class MMSignature
# Htlm transcription of the signature (with nested links)
- meth to_html(dctx: DocContext): String
+ fun to_html(dctx: DocContext, with_closure: Bool): String
do
var res = new Buffer
if arity > 0 then
res.append(": ")
res.append(return_type.html_link(dctx))
end
+ if with_closure then
+ for c in closures do
+ res.append(" ")
+ if c.is_optional then res.append("[")
+ if c.is_break then res.append("break ")
+ res.append("!{c.name}")
+ res.append(c.signature.to_html(dctx, false))
+ if c.is_optional then res.append("]")
+ end
+ end
return res.to_s
end
end
redef class MMType
# Htlm transcription of the type (with nested links)
- meth html_link(dctx: DocContext): String do return to_s
+ fun html_link(dctx: DocContext): String do return to_s
end
redef class MMTypeSimpleClass
- redef meth html_link(dctx) do return local_class.html_link(dctx)
+ redef fun html_link(dctx) do return local_class.html_link(dctx)
end
redef class MMTypeGeneric
- redef meth html_link(dctx)
+ redef fun html_link(dctx)
do
var res = new Buffer
res.append(local_class.html_link(dctx))
nitlanguage / nit.git / blobdiff