X-Git-Url: http://nitlanguage.org diff --git a/src/ni_nitdoc.nit b/src/ni_nitdoc.nit index e1da32b..f928914 100644 --- a/src/ni_nitdoc.nit +++ b/src/ni_nitdoc.nit @@ -28,6 +28,7 @@ class Nitdoc private var arguments: Array[String] private var destinationdir: nullable String private var sharedir: nullable String + private var source: nullable String private var opt_dir = new OptionString("Directory where doc is generated", "-d", "--dir") private var opt_source = new OptionString("What link for source (%f for filename, %l for first line, %L for last line)", "--source") @@ -38,10 +39,12 @@ class Nitdoc # We need a model to collect stufs self.toolcontext = toolcontext self.arguments = toolcontext.option_context.rest + toolcontext.option_context.options.clear toolcontext.option_context.add_option(opt_dir) toolcontext.option_context.add_option(opt_source) toolcontext.option_context.add_option(opt_sharedir) toolcontext.option_context.add_option(opt_nodot) + toolcontext.process_options process_options if arguments.length < 1 then @@ -86,6 +89,11 @@ class Nitdoc abort end end + if not opt_source.value is null then + source = "" + else + source = opt_source.value + end end fun start do @@ -94,43 +102,99 @@ class Nitdoc if not destinationdir.file_exists then destinationdir.mkdir sys.system("cp -r {sharedir.to_s}/* {destinationdir.to_s}/") overview + fullindex + modules + classes + quicksearch_list end end fun overview do - var overviewpage = new NitdocOverview.with(modelbuilder.nmodules, self.opt_nodot.value, destinationdir.to_s) + var overviewpage = new NitdocOverview.with(modelbuilder, self.opt_nodot.value, destinationdir.to_s) overviewpage.save("{destinationdir.to_s}/index.html") end -end + fun fullindex do + var fullindex = new NitdocFullindex.with(model.mmodules) + fullindex.save("{destinationdir.to_s}/full-index.html") + end -class NitdocOverview - super NitdocPage + fun modules do + for mmodule in model.mmodules do + var modulepage = new NitdocModule.with(mmodule, modelbuilder) + modulepage.save("{destinationdir.to_s}/{mmodule.name}.html") + end + end - var amodules: Array[AModule] + fun classes do + for mclass in modelbuilder.model.mclasses do + var classpage = new NitdocClass.with(mclass, modelbuilder, source) + classpage.save("{destinationdir.to_s}/{mclass.name}.html") + end + end - # Init with Array[AModule] to get all ifnormations about each MModule containt in a program - # opt_nodot to inform about the graph gen - # destination: to know where will be saved dot files - init with(modules: Array[AModule], opt_nodot: Bool, destination: String) do - self.amodules = modules - self.opt_nodot = opt_nodot - self.destinationdir = destination + # Generate QuickSearch file + fun quicksearch_list do + var file = new OFStream.open("{destinationdir.to_s}/quicksearch-list.js") + var content = new Buffer + content.append("var entries = \{ ") + for prop in model.mproperties do + if not prop isa MMethod then continue + content.append("\"{prop.name}\": [") + for propdef in prop.mpropdefs do + content.append("\{txt: \"{propdef.mproperty.full_name}\", url:\"{propdef.mproperty.link_anchor}\" \}") + if not propdef is prop.mpropdefs.last then content.append(", ") + end + content.append("]") + content.append(", ") + end + + for mclass in model.mclasses do + content.append("\"{mclass.name}\": [") + for mclassdef in mclass.mclassdefs do + content.append("\{txt: \"{mclassdef.mclass.full_name}\", url:\"{mclass.link_anchor}\" \}") + if not mclassdef is mclass.mclassdefs.last then content.append(", ") + end + content.append("]") + if not mclass is model.mclasses.last then content.append(", ") + end + + content.append(" \};") + file.write(content.to_s) + file.close end +end + +# Nitdoc base page +abstract class NitdocPage + super HTMLPage + + var opt_nodot: Bool + var destinationdir : String + var source: nullable String + redef fun head do - super - add("title").text("Overview | Nit Standard Library") + add("meta").attr("charset", "utf-8") + add("script").attr("type", "text/javascript").attr("src", "scripts/jquery-1.7.1.min.js") + add("script").attr("type", "text/javascript").attr("src", "quicksearch-list.js") + add("script").attr("type", "text/javascript").attr("src", "scripts/js-facilities.js") + add("link").attr("rel", "stylesheet").attr("href", "styles/main.css").attr("type", "text/css").attr("media", "screen") end - redef fun header do + redef fun body do + header + content + footer + end + + fun menu is abstract + + fun header do open("header") open("nav").add_class("main") open("ul") - add("li").add_class("current").text("Overview") - open("li") - add_html("Full Index") - close("li") + menu open("li").attr("id", "liGitHub") open("a").add_class("btn").attr("id", "logGitHub") add("img").attr("id", "imgGitHub").attr("src", "resources/icons/github-icon.png") @@ -175,8 +239,74 @@ class NitdocOverview close("header") end - redef fun body do + fun content is abstract + + fun footer do + add("footer").text("Nit standard library. Version jenkins-component=stdlib-19.") + end + + # Generate a clickable graphviz image using a dot content + fun generate_dot(dot: String, name: String, alt: String) do + if opt_nodot then return + var file = new OFStream.open("{self.destinationdir}/{name}.dot") + file.write(dot) + file.close + sys.system("\{ test -f {self.destinationdir}/{name}.png && test -f {self.destinationdir}/{name}.s.dot && diff {self.destinationdir}/{name}.dot {self.destinationdir}/{name}.s.dot >/dev/null 2>&1 ; \} || \{ cp {self.destinationdir}/{name}.dot {self.destinationdir}/{name}.s.dot && dot -Tpng -o{self.destinationdir}/{name}.png -Tcmapx -o{self.destinationdir}/{name}.map {self.destinationdir}/{name}.s.dot ; \}") + open("article").add_class("graph") + add("img").attr("src", "{name}.png").attr("usemap", "#{name}").attr("style", "margin:auto").attr("alt", "{alt}") + close("article") + var fmap = new IFStream.open("{self.destinationdir}/{name}.map") + add_html(fmap.read_all) + fmap.close + end + + # Add a (source) link for a given location + fun show_source(l: Location): String + do + if source == null then + return "({l.file.filename.simplify_path})" + else + # THIS IS JUST UGLY ! (but there is no replace yet) + var x = source.split_with("%f") + source = x.join(l.file.filename.simplify_path) + x = source.split_with("%l") + source = x.join(l.line_start.to_s) + x = source.split_with("%L") + source = x.join(l.line_end.to_s) + return " (show code)" + end + end + +end + +# The overview page +class NitdocOverview + super NitdocPage + + var mbuilder: ModelBuilder + + # Init with Array[AModule] to get all ifnormations about each MModule containt in a program + # opt_nodot to inform about the graph gen + # destination: to know where will be saved dot files + init with(mbuilder: ModelBuilder, opt_nodot: Bool, destination: String) do + self.mbuilder = mbuilder + self.opt_nodot = opt_nodot + self.destinationdir = destination + end + + redef fun head do super + add("title").text("Overview | Nit Standard Library") + end + + redef fun menu do + add("li").add_class("current").text("Overview") + open("li") + add_html("Full Index") + close("li") + end + + redef fun content do open("div").add_class("page") open("div").add_class("content fullpage") add("h1").text("Nit Standard Library") @@ -188,57 +318,654 @@ class NitdocOverview open("ul") add_modules close("ul") + process_generate_dot close("article") close("div") close("div") - add("footer").text("Nit standard library. Version jenkins-component=stdlib-19.") end fun add_modules do + var mmodules = list_mmodules + var sorted = new Array[MModule].from(mmodules) + var sorter = new ComparableSorter[MModule] + sorter.sort(sorted) + for mmodule in sorted do + var amodule = mbuilder.mmodule2nmodule[mmodule] + open("li") + add_html(mmodule.link(amodule)) + add_html(" ") + add_html(amodule.short_comment) + close("li") + end + end + + fun process_generate_dot do + var op = new Buffer + op.append("digraph dep \{ rankdir=BT; node[shape=none,margin=0,width=0,height=0,fontsize=10]; edge[dir=none,color=gray]; ranksep=0.2; nodesep=0.1;\n") + for mmodule in list_mmodules do + op.append("\"{mmodule.name}\"[URL=\"{mmodule.name}.html\"];\n") + for imported in mmodule.in_importation.direct_greaters do + if imported.direct_owner == null then + op.append("\"{mmodule.name}\"->\"{imported.name}\";\n") + end + end + end + op.append("\}\n") + generate_dot(op.to_s, "dep", "Modules hierarchy") + end + + private fun list_mmodules: Set[MModule] do + var mmodules = new HashSet[MModule] + for mmodule in mbuilder.model.mmodules do + var owner = mmodule.public_owner + if owner != null then + mmodules.add(owner) + else + mmodules.add(mmodule) + end + end + return mmodules + end +end + +# The full index page +class NitdocFullindex + super NitdocPage + + var mmodules: Array[MModule] + + init with(mmodules: Array[MModule]) do + self.mmodules = mmodules + opt_nodot = false + destinationdir = "" + end + + redef fun head do + super + add("title").text("Full Index | Nit Standard Library") + end + + redef fun menu do + open("li") + add_html("Overview") + close("li") + add("li").add_class("current").text("Full Index") + end + + redef fun content do + open("div").add_class("page") + open("div").add_class("content fullpage") + add("h1").text("Full Index") + module_column + classes_column + properties_column + close("div") + close("div") + end + + # Add to content modules column + fun module_column do var ls = new List[nullable MModule] - for amodule in amodules do - var mmodule = amodule.mmodule.public_owner - if mmodule != null and not ls.has(mmodule) then + var sorted = mmodules + var sorterp = new ComparableSorter[MModule] + sorterp.sort(sorted) + open("article").add_class("modules filterable") + add("h2").text("Modules") + open("ul") + for mmodule in sorted do + if mmodule.public_owner != null and not ls.has(mmodule.public_owner) then + ls.add(mmodule.public_owner) open("li") - add("a").attr("href", "{mmodule.name}.html").text("{mmodule.to_s} ") - add_html(amodule.comment) + add("a").attr("href", "{mmodule.public_owner.name}.html").text(mmodule.public_owner.name) close("li") - ls.add(mmodule) end end + close("ul") + close("article") + end + + # Add to content classes modules + fun classes_column do + var sorted = mmodules.first.imported_mclasses.to_a + var sorterp = new ComparableSorter[MClass] + sorterp.sort(sorted) + open("article").add_class("classes filterable") + add("h2").text("Classes") + open("ul") + + for mclass in sorted do + open("li") + add("a").attr("href", "{mclass.name}.html").text(mclass.name) + close("li") + end + + close("ul") + close("article") + end + + # Insert the properties column of fullindex page + fun properties_column do + open("article").add_class("properties filterable") + add("h2").text("Properties") + open("ul") + var sorted_imported = mmodules.first.imported_methods.to_a + var sorted_redef = mmodules.first.redef_methods.to_a + var sorterp = new ComparableSorter[MProperty] + sorterp.sort(sorted_imported) + sorterp.sort(sorted_redef) + + for method in sorted_imported do + if method.visibility is none_visibility or method.visibility is intrude_visibility then continue + open("li").add_class("intro") + add("span").attr("title", "introduction").text("I") + add_html(" ") + add("a").attr("href", "{method.local_class.name}.html").attr("title", "").text("{method.name} ({method.local_class.name})") + close("li") + end + + for method in sorted_redef do + if method.visibility is none_visibility or method.visibility is intrude_visibility then continue + open("li").add_class("redef") + add("span").attr("title", "redefinition").text("R") + add_html(" ") + add("a").attr("href", "{method.local_class.name}.html").attr("title", "").text("{method.name} ({method.local_class.name})") + close("li") + end + + close("ul") + close("article") end end -class NitdocPage - super HTMLPage - var opt_nodot: Bool - var destinationdir : String +# A module page +class NitdocModule + super NitdocPage + + var mmodule: MModule + var mbuilder: ModelBuilder + + init with(mmodule: MModule, mbuilder: ModelBuilder) do + self.mmodule = mmodule + self.mbuilder = mbuilder + opt_nodot = false + destinationdir = "" + end redef fun head do - add("meta").attr("charset", "utf-8") - add("script").attr("type", "text/javascript").attr("src", "scripts/jquery-1.7.1.min.js") - add("script").attr("type", "text/javascript").attr("src", "quicksearch-list.js") - add("script").attr("type", "text/javascript").attr("src", "scripts/js-facilities.js") - add("link").attr("rel", "stylesheet").attr("href", "styles/main.css").attr("type", "text/css").attr("media", "screen") + super + var amodule = mbuilder.mmodule2nmodule[mmodule] + add("title").text("{mmodule.name} module | {amodule.short_comment}") end - redef fun body do header - fun header do end + redef fun menu do + open("li") + add_html("Overview") + close("li") + add("li").add_class("current").text(mmodule.name) + open("li") + add_html("Full Index") + close("li") + end + + redef fun content do + open("div").add_class("page") + sidebar + open("div").add_class("content") + add("h1").text(mmodule.name) + add("div").add_class("subtitle").text("module {mmodule.name}") + module_comment + #process_generate_dot + classes + properties + close("div") + close("div") + end + + # Insert module comment in the content + fun module_comment do + var amodule = mbuilder.mmodule2nmodule[mmodule] + var doc = amodule.comment + open("div").attr("id", "description") + add("pre").add_class("text_label").text(doc) + add("textarea").add_class("edit").attr("rows", "1").attr("cols", "76").attr("id", "fileContent").text(" ") + add("a").attr("id", "cancelBtn").text("Cancel") + add("a").attr("id", "commitBtn").text("Commit") + add("pre").add_class("text_label").attr("id", "preSave").attr("type", "2") + close("div") + end + + fun process_generate_dot do + var op = new Buffer + op.append("digraph dep \{ rankdir=BT; node[shape=none,margin=0,width=0,height=0,fontsize=10]; edge[dir=none,color=gray]; ranksep=0.2; nodesep=0.1;\n") + for m in mmodule.in_importation.smallers do + op.append("\"{m.name}\"[URL=\"{m.name}.html\"];\n") + for imported in m.in_importation.direct_greaters do + if imported.direct_owner == null then + op.append("\"{m.name}\"->\"{imported.name}\";\n") + end + end + end + op.append("\}\n") + generate_dot(op.to_s, "dep_{mmodule.name}", "Modules hierarchy") + end + + fun sidebar do + var amodule = mbuilder.mmodule2nmodule[mmodule] + open("div").add_class("menu") + open("nav") + add("h3").text("Module Hierarchy").attr("style","cursor: pointer;") + if mmodule.in_importation.greaters.length > 0 then + add_html("
{nclass.comment}CancelCommit") + close("section") + open("section").add_class("concerns") + add("h2").add_class("section-header").text("Concerns") + open("ul") + for owner in sorted do + var nmodule = mbuilder.mmodule2nmodule[owner] + var childs = mclass.concerns[owner] + open("li") + add_html("{owner.name}: {nmodule.short_comment}") + if not childs is null then + open("ul") + var sortedc = childs.to_a + var sorterpc = new ComparableSorter[MModule] + sorterpc.sort(sortedc) + for child in sortedc do + var nchild = mbuilder.mmodule2nmodule[child] + add_html("
{mmodule.name}: {nmodule.short_comment}
") + else + add_html("{mmodule.name}: {nmodule.short_comment}
") + end + end + var sortedc = mmethods.to_a + sorterprop.sort(sortedc) + for prop in sortedc do description(prop) + end + # Insert inherited methods + if mclass.inherited_methods.length > 0 then + var sortedc = new Array[MClass] + sortedc.add_all(mclass.inherited.keys) + sorterc.sort(sortedc) + add("h3").text("Inherited Methods") + for i_mclass in sortedc do + var sortedp = mclass.inherited[i_mclass].to_a + sorterprop.sort(sortedp) + open("p") + add_html("Defined in {i_mclass.name}: ") + for method in sortedp do + add_html("{method.name}") + if method != sortedp.last then add_html(", ") + end + close("p") + end + end + close("section") + end + + # Insert description tags for 'prop' + fun description(prop: MProperty) do + open("article").add_class("fun public {if prop.is_redef then "redef" else ""}").attr("id", "{prop.anchor}") + var sign = prop.name + if prop.apropdef != null then sign += prop.apropdef.signature + add_html("{prop.apropdef.comment}") + end + add_html("CancelCommit") + open("p") + if prop.local_class != mclass then + var mredef = prop.local_class.intro_mmodule + var nredef = mbuilder.mmodule2nmodule[mredef] + add_html("inherited from {mredef.link(nredef)} ") + end + #TODO display show code if doc github + var mintro = prop.intro_mclassdef.mmodule + var nintro = mbuilder.mmodule2nmodule[mintro] + add_html("defined by the module {mintro.link(nintro)}{if prop.apropdef is null then "" else show_source(prop.apropdef.location)}.") + + for parent in mclass.parents do + var mparent = parent.intro_mmodule + var nparent = mbuilder.mmodule2nmodule[mparent] + if prop isa MMethod then if parent.constructors.has(prop) then add_html(" Previously defined by: {mparent.link(nparent)} for {parent.name}.") + end + close("p") + close("div") - # Generate a clickable graphviz image using a dot content - fun generate_dot(dot: String, name: String, alt: String) do - if opt_nodot then return - var file = new OFStream.open("{self.destinationdir}/{name}.dot") - file.write(dot) - file.close - sys.system("\{ test -f {self.destinationdir}/{name}.png && test -f {self.destinationdir}/{name}.s.dot && diff {self.destinationdir}/{name}.dot {self.destinationdir}/{name}.s.dot >/dev/null 2>&1 ; \} || \{ cp {self.destinationdir}/{name}.dot {self.destinationdir}/{name}.s.dot && dot -Tpng -o{self.destinationdir}/{name}.png -Tcmapx -o{self.destinationdir}/{name}.map {self.destinationdir}/{name}.s.dot ; \}") - open("article").add_class("graph") - add("img").attr("src", "{name}.png").attr("usemap", "#{name}").attr("style", "margin:auto").attr("alt", "{alt}") close("article") - var fmap = new IFStream.open("{self.destinationdir}/{name}.map") - add_html(fmap.read_all) - fmap.close end end @@ -249,7 +976,10 @@ redef class AModule if n_moduledecl is null or n_moduledecl.n_doc is null then ret if n_moduledecl.n_doc is null then return "" for t in n_moduledecl.n_doc.n_comment do - ret += "{t.text.replace("# ", "")}" + var txt = t.text + txt = txt.replace("# ", "") + txt = txt.replace("#", "") + ret += txt end return ret end @@ -266,9 +996,304 @@ redef class AModule end end +redef class MModule + super Comparable + redef type OTHER: MModule + redef fun <(other: OTHER): Bool do return self.name < other.name + + # Get the list of all methods in a module + fun imported_methods: Set[MMethod] do + var methods = new HashSet[MMethod] + for mclass in imported_mclasses do + for method in mclass.intro_methods do + methods.add(method) + end + end + return methods + end + + # Get the list aof all refined methods in a module + fun redef_methods: Set[MMethod] do + var methods = new HashSet[MMethod] + for mclass in redef_mclasses do + for method in mclass.intro_methods do + methods.add(method) + end + end + return methods + end + + # Return a link (html a tag) to the nitdoc module page + fun link(amodule: AModule): String do + return "{name}" + end +end +redef class MPropDef + super Comparable + redef type OTHER: MPropDef + redef fun <(other: OTHER): Bool do return self.mproperty.name < other.mproperty.name +end + +redef class MProperty + super Comparable + redef type OTHER: MProperty + redef fun <(other: OTHER): Bool do return self.name < other.name + + var is_redef: Bool + var apropdef: nullable APropdef + + redef init(intro_mclassdef: MClassDef, name: String, visibility: MVisibility) + do + super + is_redef = false + end + + fun local_class: MClass do + var classdef = self.intro_mclassdef + return classdef.mclass + end + + fun class_text: String do + return local_class.name + end + + fun link_anchor: String do + return "{class_text}.html#{anchor}" + end + + fun anchor: String do + return "PROP_{c_name}" + end + +end + +redef class MClass + super Comparable + redef type OTHER: MClass + redef fun <(other: OTHER): Bool do return self.name < other.name + + # Associate all MMethods to each MModule concerns + fun all_methods: HashMap[MModule, Set[MMethod]] do + var hm = new HashMap[MModule, Set[MMethod]] + for mmodule, childs in concerns do + if not hm.has_key(mmodule) then hm[mmodule] = new HashSet[MMethod] + for prop in intro_methods do + if mmodule == prop.intro_mclassdef.mmodule then + prop.is_redef = false + hm[mmodule].add(prop) + end + end + for prop in redef_methods do + if mmodule == prop.intro_mclassdef.mmodule then + prop.is_redef = true + hm[mmodule].add(prop) + end + end + + if childs != null then + for child in childs do + if not hm.has_key(child) then hm[child] = new HashSet[MMethod] + for prop in intro_methods do + if child == prop.intro_mclassdef.mmodule then + prop.is_redef = false + hm[child].add(prop) + end + end + for prop in redef_methods do + if child == prop.intro_mclassdef.mmodule then + prop.is_redef = true + hm[child].add(prop) + end + end + end + end + end + return hm + end + + fun public_owner: MModule do + var owner = intro_mmodule + if owner.public_owner is null then + return owner + else + return owner.public_owner.as(not null) + end + end + + # Associate MClass to all MMethod include in 'inherited_methods' + fun inherited: HashMap[MClass, Set[MMethod]] do + var hm = new HashMap[MClass, Set[MMethod]] + for method in inherited_methods do + var mclass = method.intro_mclassdef.mclass + if not hm.has_key(mclass) then hm[mclass] = new HashSet[MMethod] + hm[mclass].add(method) + end + return hm + end + + # Return true if MModule concern contain subMModule + fun has_mmodule(sub: MModule): Bool do + for mmodule, childs in concerns do + if childs is null then continue + if childs.has(sub) then return true + end + return false + end + + fun mmethod(mprop2npropdef: Map[MProperty, APropdef]) do + for const in constructors do + if mprop2npropdef.has_key(const)then + const.apropdef = mprop2npropdef[const].as(AMethPropdef) + end + end + + for intro in intro_methods do + if mprop2npropdef.has_key(intro)then + if mprop2npropdef[intro] isa AMethPropdef then intro.apropdef = mprop2npropdef[intro].as(AMethPropdef) + end + end + + for rd in redef_methods do + if mprop2npropdef.has_key(rd)then + if mprop2npropdef[rd] isa AMethPropdef then rd.apropdef = mprop2npropdef[rd].as(AMethPropdef) + end + end + end + + fun link_anchor: String do + return "{name}.html" + end + +end + +redef class AStdClassdef + private fun comment: String do + var ret = "" + if n_doc != null then + for t in n_doc.n_comment do + var txt = t.text.replace("# ", "") + txt = txt.replace("#", "") + ret += "{txt}" + end + end + return ret + end + + private fun short_comment: String do + var ret = "" + if n_doc != null then + var txt = n_doc.n_comment.first.text + txt = txt.replace("# ", "") + txt = txt.replace("\n", "") + ret += txt + end + return ret + end +end + +redef class ASignature + redef fun to_s do + #TODO closures + var ret = "" + if not n_params.is_empty then + ret = "{ret}({n_params.join(", ")})" + end + if n_type != null and n_type.to_s != "" then ret += " {n_type.to_s}" + return ret + end +end + +redef class AParam + redef fun to_s do + var ret = "{n_id.text}" + if n_type != null then + ret = "{ret}: {n_type.to_s}" + if n_dotdotdot != null then ret = "{ret}..." + end + return ret + end +end + +redef class AType + redef fun to_s do + var ret = "{n_id.text}" + if n_kwnullable != null then ret = "nullable {ret}" + if not n_types.is_empty then ret = "{ret}[{n_types.join(", ")}]" + return ret + end +end + +redef class APropdef + private fun short_comment: String is abstract + private fun signature: String is abstract + private fun comment: String is abstract +end + +redef class AAttrPropdef + redef fun short_comment do + var ret = "" + if n_doc != null then + var txt = n_doc.n_comment.first.text + txt = txt.replace("# ", "") + txt = txt.replace("\n", "") + ret += txt + end + return ret + end +end + +redef class AMethPropdef + redef fun short_comment do + var ret = "" + if n_doc != null then + var txt = n_doc.n_comment.first.text + txt = txt.replace("# ", "") + txt = txt.replace("\n", "") + ret += txt + end + return ret + end + + redef fun signature: String do + var sign = "" + if n_signature != null then sign = " {n_signature.to_s}" + return sign + end + + redef private fun comment: String do + var ret = "" + if n_doc != null then + for t in n_doc.n_comment do + var txt = t.text.replace("# ", "") + txt = txt.replace("#", "") + ret += "{txt}" + end + end + return ret + end +end + +redef class MClassDef + private fun namespace(mclass: MClass): String do + + if mmodule.public_owner is null then + return "{mmodule.full_name}::{mclass.name}" + else if mclass is self.mclass then + return "{mmodule.public_owner.name}::{mclass.name}" + else + return "{mmodule.public_owner.name}::{mclass.name}" + end + end +end + +redef class Set[E] + fun last: E do + return to_a[length-1] + end +end + # Create a tool context to handle options and paths var toolcontext = new ToolContext -toolcontext.process_options # Here we launch the nit index var nitdoc = new Nitdoc(toolcontext)