src/nitdoc.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2008 Jean Privat <jean@pryen.org>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # The main module of the nitdoc program
  18 package nitdoc
  19
  20 import syntax
  21 private import utils
  22 import abstracttool
  23
  24
  25 # Store knowledge and facilities to generate files
  26 class DocContext
  27         super AbstractCompiler
  28         # Destination directory
  29         readable writable var _dir: String = "doc"
  30
  31         # Content of a generated file
  32         var _stage_context: StageContext = new StageContext(null)
  33
  34         # Add a string in the content
  35         fun add(s: String) do
  36                 _stage_context.content.add(s)
  37                 _stage_context.validate = true
  38         end
  39
  40         # Add a string in the content iff some other string are added
  41         fun stage(s: String) do _stage_context.content.add(s)
  42
  43         # Create a new stage in the content
  44         fun open_stage do _stage_context = new StageContext(_stage_context)
  45
  46         # Close the current stage in the content
  47         fun close_stage
  48         do
  49                 var s = _stage_context.parent
  50                 if _stage_context.validate then
  51                         s.content.add_all(_stage_context.content)
  52                         s.validate = true
  53                 end
  54                 assert s != null
  55                 _stage_context = s
  56         end
  57
  58         # Write the content to a new file
  59         fun write_to(filename: String)
  60         do
  61                 var f = new OFStream.open(filename)
  62                 for s in _stage_context.content do
  63                         f.write(s)
  64                 end
  65                 f.close
  66         end
  67
  68         # Start a new file
  69         fun clear
  70         do
  71                 _stage_context = new StageContext(null)
  72         end
  73
  74         # Sorter of entities in alphabetical order
  75         var _sorter: AlphaSorter[MMEntity] = new AlphaSorter[MMEntity]
  76
  77         # Sort entities in the alphabetical order
  78         fun sort(array: Array[MMEntity])
  79         do
  80                 _sorter.sort(array)
  81         end
  82
  83         readable var _opt_dir: OptionString = new OptionString("Directory where doc is generated", "-d", "--dir")
  84         readable var _opt_source: OptionString = new OptionString("What link for source (%f for filename, %l for first line, %L for last line)", "--source")
  85         readable var _opt_public: OptionBool = new OptionBool("Generate only the public API", "--public")
  86         readable var _opt_private: OptionBool = new OptionBool("Generate the private API", "--private")
  87         readable var _opt_nodot: OptionBool = new OptionBool("Do not generate graphes with graphviz", "--no-dot")
  88         readable var _opt_sharedir: OptionString = new OptionString("Directory containing the nitdoc files", "--sharedir")
  89
  90         readable var _opt_custom_menu_items: OptionString = new OptionString("Items displayed in menu before the 'Overview' item (Each item must be enclosed in 'li' tags)", "--custom-menu-items")
  91         readable var _opt_custom_title: OptionString = new OptionString("Title displayed in the top of the Overview page and as suffix of all page names", "--custom-title")
  92         readable var _opt_custom_overview_text: OptionString = new OptionString("Text displayed as introduction of Overview page before the modules list", "--custom-overview-text")
  93         readable var _opt_custom_footer_text: OptionString = new OptionString("Text displayed as footer of all pages", "--custom-footer-text")
  94         var sharedir: nullable String
  95
  96         fun public_only: Bool
  97         do
  98                 if self._opt_public.value == true then return true
  99                 return false
 100         end
 101
 102         fun with_private: Bool
 103         do
 104                 if self._opt_private.value == true then return true
 105                 return false
 106         end
 107
 108         # The current processed filename
 109         var filename: String
 110
 111         # The main virtual module
 112         var mainmod: nullable MMVirtualModule
 113
 114         redef fun perform_work(mods)
 115         do
 116                 mainmod = new MMVirtualModule(self, mods)
 117
 118                 dir.mkdir
 119
 120                 sys.system("cp -r '{sharedir.to_s}'/* {dir}/")
 121
 122                 # Compute the set of direct owned nested modules
 123                 var owns = new HashMap[MMModule, Array[MMModule]]
 124                 for mod in modules do
 125                         owns[mod] = new Array[MMModule]# [mod]
 126                 end
 127                 for mod in modules do
 128                         if mod == mainmod then continue
 129                         var d = mod.directory
 130                         loop
 131                                 var o = d.owner
 132                                 if o != null and o != mod then
 133                                         owns[o].add(mod)
 134                                 end
 135                                 var dp = d.parent
 136                                 if dp == null or dp == d then break
 137                                 d = dp
 138                         end
 139                 end
 140
 141                 # Builds the various module hierarchies
 142                 var mnh = new PartialOrder[MMModule] # nested module hierarchy
 143                 var tmh = new PartialOrder[MMModule] # top module import hierrchy
 144                 var ms = mainmod.mhe.linear_extension.reversed
 145                 for m in ms do
 146                         if ms == mainmod then continue
 147                         m.mnhe_ = mnh.add(m, owns[m])
 148                         var pub = new Array[MMModule]
 149                         for m2 in m.mhe.greaters do
 150                                 if m2.toplevel_owner != m2 and m2.toplevel_owner != m.toplevel_owner then continue
 151                                 if m.mnhe <= m2 then continue
 152                                 if m.visibility_for(m2) <= 0 then
 153                                         # nothing
 154                                 else if m.visibility_for(m2) == 1 then
 155                                 else
 156                                         pub.add(m2)
 157                                 end
 158                         end
 159                         m.tmhe_ = tmh.add(m, pub)
 160                 end
 161
 162                 var head = "<meta charset=\"utf-8\">" +
 163                         "<script type=\"text/javascript\" src=\"scripts/jquery-1.7.1.min.js\"></script>\n" +
 164                         "<script type=\"text/javascript\" src=\"quicksearch-list.js\"></script>\n" +
 165                         "<script type=\"text/javascript\" src=\"scripts/js-facilities.js\"></script>\n" +
 166                         "<link rel=\"stylesheet\" href=\"styles/main.css\" type=\"text/css\"  media=\"screen\" />"
 167
 168                 var custom_items = ""
 169                 if self._opt_custom_menu_items.value != null then custom_items = self._opt_custom_menu_items.value.as(not null)
 170
 171                 var action_bar = "<header><nav class='main'><ul>{custom_items}<li class=\"current\">Overview</li><li><a href='full-index.html'>Full Index</a></li><li><a href=\"help.html\">Help</a></li></ul></nav></header>\n"
 172
 173                 var custom_title = "Nitdoc"
 174                 if self._opt_custom_title.value != null then custom_title = self._opt_custom_title.value.as(not null)
 175
 176                 var overview_text = ""
 177                 if self._opt_custom_overview_text.value != null then overview_text = self._opt_custom_overview_text.value.as(not null)
 178
 179                 var footer_text = ""
 180                 if self._opt_custom_footer_text.value != null then footer_text = self._opt_custom_footer_text.value.as(not null)
 181
 182                 # generate the index
 183                 self.filename = "index.html"
 184                 clear
 185                 add("<!DOCTYPE html>")
 186                 add("<html><head>{head}<title>Overview | {custom_title}</title></head><body>\n")
 187                 add(action_bar)
 188                 add("<div class=\"page\">")
 189                 add("<div class=\"content fullpage\">")
 190                 add("<h1>{custom_title}</h1>\n<article class='overview'>{overview_text}</article><article class='overview'><h2>Modules</h2><ul>")
 191                 var modss = mainmod.mhe.greaters_and_self.to_a
 192                 sort(modss)
 193                 for mod in modss do
 194                         if not mod.is_toplevel then continue
 195                         if not mod.require_doc(self) then continue
 196                         assert mod isa MMSrcModule
 197                         add("<li>{mod.html_link(self)} {mod.short_doc}</li>")
 198
 199                 end
 200                 add("</ul>")
 201
 202                 var op = new Buffer
 203                 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")
 204                 for mod in modss do
 205                         if not mod.is_toplevel then continue
 206                         if not mod.require_doc(self) then continue
 207                         op.append("\"{mod.name}\"[URL=\"{mod.html_name}.html\"];\n")
 208                         for mod2 in mod.tmhe.direct_greaters do
 209                                 if not modss.has(mod2) then continue
 210                                 op.append("\"{mod.name}\"->\"{mod2.name}\";\n")
 211                         end
 212                 end
 213                 op.append("\}\n")
 214                 self.gen_dot(op.to_s, "dep", "Modules hierarchy")
 215                 add("</article></div>")
 216                 add("<div class='clear'></div>")
 217                 add("</div>")
 218                 add("<footer>{footer_text}</footer>")
 219                 add("</body></html>\n")
 220                 write_to("{dir}/index.html")
 221
 222                 # Generate page for modules
 223                 for mod in modules do
 224                         if mod == mainmod then continue
 225                         assert mod isa MMSrcModule
 226                         if not mod.require_doc(self) then continue
 227                         self.filename = mod.html_name
 228                         action_bar = "<header><nav class='main'><ul>{custom_items}<li><a href='./index.html'>Overview</a></li><li class=\"current\">{mod.name}</li><li><a href='full-index.html'>Full Index</a></li><li><a href=\"help.html\">Help</a></li></ul></nav></header>\n"
 229                         clear
 230                         add("<!DOCTYPE html>")
 231                         add("<html><head>{head}<title>{mod.name} module | {custom_title}</title></head><body>\n")
 232                         add(action_bar)
 233                         add("<div class=\"page\">")
 234                         mod.file_page_doc(self)
 235                         add("</div>")
 236                         add("<footer>{footer_text}</footer>")
 237                         add("</body></html>\n")
 238                         write_to("{dir}/{mod.html_name}.html")
 239                 end
 240
 241                 # Generate pages for global classes
 242                 for c in mainmod.local_classes do
 243                         if not c.require_doc(self) then continue
 244                         self.filename = c.html_name
 245                         action_bar = "<header><nav class='main'><ul>{custom_items}<li><a href='./index.html'>Overview</a></li><li>{c.global.intro.mmmodule.toplevel_owner.html_link(self)}</li><li class=\"current\">{c.name}</li><li><a href='full-index.html'>Full Index</a></li><li><a href=\"help.html\">Help</a></li></ul></nav></header>\n"
 246                         clear
 247                         add("<!DOCTYPE html>")
 248                         add("<html><head>{head}<title>{c.name} class | {custom_title}</title></head><body>\n")
 249                         add(action_bar)
 250                         add("<div class=\"page\">")
 251                         c.file_page_doc(self)
 252                         add("</div>")
 253                         add("<footer>{footer_text}</footer>")
 254                         add("</body></html>\n")
 255                         write_to("{dir}/{c.html_name}.html")
 256                 end
 257
 258                 self.filename = "fullindex"
 259                 action_bar = "<header><nav class='main'><ul>{custom_items}<li><a href='./index.html'>Overview</a></li><li class=\"current\">Full Index</li><li><a href=\"help.html\">Help</a></li></ul></nav></header>\n"
 260                 clear
 261                 add("<!DOCTYPE html>")
 262                 add("<html><head>{head}<title>Full Index | {custom_title}</title></head><body>\n")
 263                 add(action_bar)
 264                 add("<div class=\"page\">")
 265                 add("<div class=\"content fullpage\">")
 266                 mainmod.file_index_page_doc(self)
 267                 add("</div>")
 268                 add("</div>")
 269                 add("<footer>{footer_text}</footer>")
 270                 add("</body></html>\n")
 271                 write_to("{dir}/full-index.html")
 272
 273                 self.filename = "quicksearch-list"
 274                 clear
 275                 mainmod.file_quicksearch_list_doc(self)
 276                 write_to("{dir}/quicksearch-list.js")
 277         end
 278
 279
 280         # Add a (source) link fo a given location
 281         fun show_source(l: Location)
 282         do
 283                 var s = opt_source.value
 284                 if s == null then
 285                         add("in {l.file.filename.simplify_path}")
 286                 else
 287                         # THIS IS JUST UGLY ! (but there is no replace yet)
 288                         var x = s.split_with("%f")
 289                         s = x.join(l.file.filename.simplify_path)
 290                         x = s.split_with("%l")
 291                         s = x.join(l.line_start.to_s)
 292                         x = s.split_with("%L")
 293                         s = x.join(l.line_end.to_s)
 294                         add(" (<a href=\"{s}\">show code</a>)")
 295                 end
 296         end
 297
 298         # Generate a clicable graphiz image using a dot content.
 299         # `name' refer to the filename (without extension) and the id name of the map.
 300         # `name' must also match the name of the graph in the dot content (eg. digraph NAME {...)
 301         fun gen_dot(dot: String,  name: String, alt: String)
 302         do
 303                 if opt_nodot.value then return
 304                 var f = new OFStream.open("{self.dir}/{name}.dot")
 305                 f.write(dot)
 306                 f.close
 307                 sys.system("\{ test -f {self.dir}/{name}.png && test -f {self.dir}/{name}.s.dot && diff {self.dir}/{name}.dot {self.dir}/{name}.s.dot >/dev/null 2>&1 ; \} || \{ cp {self.dir}/{name}.dot {self.dir}/{name}.s.dot && dot -Tpng -o{self.dir}/{name}.png -Tcmapx -o{self.dir}/{name}.map {self.dir}/{name}.s.dot ; \}")
 308                 self.add("<article class=\"graph\"><img src=\"{name}.png\" usemap=\"#{name}\" style=\"margin:auto\" alt=\"{alt}\"/></article>")
 309                 var fmap = new IFStream.open("{self.dir}/{name}.map")
 310                 self.add(fmap.read_all)
 311                 fmap.close
 312         end
 313
 314         init
 315         do
 316                 keep_ast = true
 317                 super("nitdoc")
 318                 filename = "-unset-"
 319                 option_context.add_option(opt_public)
 320                 option_context.add_option(opt_private)
 321                 option_context.add_option(opt_dir)
 322                 option_context.add_option(opt_source)
 323                 option_context.add_option(opt_nodot)
 324                 option_context.add_option(opt_sharedir)
 325                 option_context.add_option(opt_custom_title)
 326                 option_context.add_option(opt_custom_menu_items)
 327                 option_context.add_option(opt_custom_overview_text)
 328                 option_context.add_option(opt_custom_footer_text)
 329         end
 330
 331         redef fun process_options
 332         do
 333                 super
 334                 var d = opt_dir.value
 335                 if d != null then dir = d
 336
 337                 if not opt_nodot.value then
 338                         # Test if dot is runable
 339                         var res = sys.system("sh -c dot </dev/null >/dev/null 2>&1")
 340                         if res != 0 then
 341                                 stderr.write "--no-dot implied since `dot' is not available. Try to install graphviz.\n"
 342                                 opt_nodot.value = true
 343                         end
 344                 end
 345
 346                 sharedir = opt_sharedir.value
 347                 if sharedir == null then
 348                         var dir = once ("NIT_DIR".to_symbol).environ
 349                         if dir.is_empty then
 350                                 dir = "{sys.program_name.dirname}/../share/nitdoc"
 351                                 if dir.file_exists then sharedir = dir
 352                         else
 353                                 dir = "{dir}/share/nitdoc"
 354                                 if dir.file_exists then sharedir = dir
 355                         end
 356                         if sharedir == null then
 357                                 fatal_error(null, "Error: Cannot locate nitdoc shared files. Uses --sharedir or envvar NIT_DIR.")
 358                         end
 359                         dir = "{sharedir.to_s}/scripts/js-facilities.js"
 360                         if sharedir == null then
 361                                 fatal_error(null, "Error: Invalid nitdoc shared files. Check --sharedir or envvar NIT_DIR.")
 362                         end
 363
 364                 end
 365         end
 366
 367         redef fun handle_property_conflict(lc, impls)
 368         do
 369                 # THIS IS SO UGLY! See MMVirtualModule
 370                 if lc.mmmodule == self.mainmod then
 371                         return # We just accept, so one in impls is arbitrary inherited
 372                 end
 373                 super
 374         end
 375 end
 376
 377 # A virtual module is used to work as an implicit main module that combine unrelated modules
 378 # Since conflict may arrise in a virtual module (the main method for instance) conflicts are disabled
 379 class MMVirtualModule
 380         super MMModule
 381         init(ctx: MMContext, mods: Array[MMModule])
 382         do
 383                 # We need to compute the whole metamodel since there is no mmbuilder to do it
 384                 super(" main".to_symbol, mods.first.directory, ctx, new Location(null,0,0,0,0))
 385                 ctx.add_module(self, mods)
 386                 for m in mods do
 387                         self.add_super_module(m, 1)
 388                 end
 389                 self.import_global_classes
 390                 self.import_local_classes
 391                 for c in self.local_classes do
 392                         c.compute_super_classes
 393                 end
 394                 for c in self.local_classes do
 395                         c.compute_ancestors
 396                 end
 397
 398         end
 399         redef fun require_doc(dctx) do return false
 400 end
 401
 402 # Conditionnal part of the text content of a DocContext
 403 class StageContext
 404         # Content of the current stage
 405         readable var _content: Array[String] = new Array[String]
 406
 407         # Is a normal string already added?
 408         readable writable var _validate: Bool = false
 409
 410         # Parent stage is any
 411         readable var _parent: nullable StageContext = null
 412
 413         init(parent: nullable StageContext) do _parent = parent
 414 end
 415
 416
 417 # Efficiently sort object with their to_s method
 418 class AlphaSorter[E: Object]
 419         super AbstractSorter[E]
 420         redef fun compare(a, b)
 421         do
 422                 var sa: String
 423                 var sb: String
 424                 var d = _dico
 425                 if d.has_key(a) then
 426                         sa = d[a]
 427                 else
 428                         sa = a.to_s
 429                         d[a] = sa
 430                 end
 431                 if d.has_key(b) then
 432                         sb = d[b]
 433                 else
 434                         sb = b.to_s
 435                         d[b] = sb
 436                 end
 437                 return sa <=> sb
 438         end
 439
 440         # Keep track of to_s values
 441         var _dico: HashMap[Object, String] = new HashMap[Object, String]
 442
 443         init do end
 444 end
 445
 446 # Generalization of metamodel entities
 447 interface MMEntity
 448         # Return a link to
 449         fun html_link(dctx: DocContext): String is abstract
 450
 451         # Return a one liner description
 452         fun short_doc: String do return "&nbsp;"
 453
 454         # The doc node from the AST
 455         # Return null is none
 456         fun doc: nullable ADoc do return null
 457
 458         # Return a jason entry for quicksearch list JSON Object
 459         fun json_entry(dctx: DocContext): String is abstract
 460
 461         # Return the qualified name as string
 462         fun qualified_name: String is abstract
 463
 464 end
 465
 466 redef class MMModule
 467         super MMEntity
 468         redef fun html_link(dctx) do
 469                 return "<a href=\"{html_name}.html\" title=\"{short_doc}\">{self}</a>"
 470         end
 471
 472         redef fun json_entry(dctx) do
 473                 return "\{txt:\"{self.qualified_name}\",url:\"{html_name}.html\"\},"
 474         end
 475
 476         redef fun qualified_name do
 477                 var buffer = new Buffer
 478                 for m in mnhe.smallers do
 479                         buffer.append("{m.html_name}::")
 480                 end
 481                 buffer.append("{self.name}")
 482                 return buffer.to_s
 483         end
 484
 485         fun require_doc(dctx: DocContext): Bool
 486         do
 487                 if dctx.public_only and not is_toplevel then return false
 488                 return true
 489         end
 490
 491         # Return true if the module is a top-level owner or a top-level module
 492         fun is_toplevel: Bool
 493         do
 494                 var pd = directory.parent
 495                 return pd == null or (pd.owner == null and directory.owner == self)
 496         end
 497
 498         # Element in the module nesting tree
 499         fun mnhe: PartialOrderElement[MMModule] do return mnhe_.as(not null)
 500         var mnhe_: nullable PartialOrderElement[MMModule] = null
 501
 502         # Element in the top level module importation hierarchy
 503         fun tmhe: PartialOrderElement[MMModule] do return tmhe_.as(not null)
 504         var tmhe_: nullable PartialOrderElement[MMModule] = null
 505
 506         fun toplevel_owner: MMModule
 507         do
 508                 var m = self
 509                 loop
 510                         var ds = m.mnhe.direct_smallers
 511                         if ds.length == 0 then return m
 512                         if ds.length == 1 then m = ds.first else abort
 513                 end
 514         end
 515
 516         fun html_name: String
 517         do
 518                 return "{name}"
 519         end
 520
 521         fun direct_owner: nullable MMModule
 522         do
 523                 var d = directory
 524                 while d.owner == self do d = d.parent.as(not null)
 525                 return d.owner
 526         end
 527
 528         # Fill the body for the page associated to the module
 529         fun file_page_doc(dctx: DocContext)
 530         do
 531                 dctx.add("<div class=\"menu\">\n")
 532
 533                 var mods = new Array[MMModule]
 534                 mods = self.mhe.greaters.to_a
 535                 dctx.sort(mods)
 536
 537                 dctx.open_stage
 538                 dctx.stage("<nav>\n")
 539                 dctx.stage("<h3>Module Hierarchy</h3>\n")
 540                 dctx.stage("<h4>All dependencies</h4>\n")
 541                 dctx.stage("<ul>\n")
 542                 for mod in mods do
 543                         if not mod.require_doc(dctx) then continue
 544                         if self.mnhe <= mod then continue # do not want nested stuff
 545                         if mod.direct_owner != null and not mod.direct_owner.mnhe <= self then continue # not in the right nesting
 546                         dctx.add("<li>{mod.html_link(dctx)}</li>")
 547                 end
 548                 dctx.stage("</ul>\n")
 549
 550                 mods = self.mhe.smallers.to_a
 551                 dctx.sort(mods)
 552                 dctx.stage("<h4>All clients</h4>\n")
 553                 dctx.stage("<ul>\n")
 554                 for mod in mods do
 555                         if not mod.require_doc(dctx) then continue
 556                         if self.mnhe <= mod then continue # do not want nested stuff
 557                         if mod.direct_owner != null and not mod.direct_owner.mnhe <= self then continue # not in the right nesting
 558                         dctx.add("<li>{mod.html_link(dctx)}</li>")
 559                 end
 560                 dctx.stage("</ul>\n")
 561                 dctx.stage("</nav>\n")
 562                 dctx.close_stage
 563
 564                 if not dctx.public_only then
 565                         mods = self.mnhe.direct_greaters.to_a
 566                         dctx.sort(mods)
 567                         dctx.open_stage
 568                         dctx.stage("<nav>\n")
 569                         dctx.stage("<h3>Nested Modules</h3><ul>\n")
 570                         for mod in mods do
 571                                 if not mod.require_doc(dctx) then continue
 572                                 dctx.add("<li>{mod.html_link(dctx)}</li>")
 573                         end
 574                         dctx.stage("</ul></nav>\n")
 575                         dctx.close_stage
 576                 end
 577
 578                 dctx.add("</div>") # metadata
 579
 580                 dctx.add("<div class=\"content\">\n")
 581                 dctx.add("<h1>{name}</h1>\n")
 582                 dctx.add("<div class='subtitle'>module ")
 583                 for m in mnhe.smallers do
 584                         dctx.add("{m.html_link(dctx)}::")
 585                 end
 586                 dctx.add("{self.name}</div>\n")
 587
 588                 dctx.add("<section class='description'>\n")
 589
 590                 var doc = doc
 591                 if doc != null then
 592                         dctx.add("<div id=\"description\">\n")
 593                         dctx.add("<pre>{doc.to_html}</pre>\n")
 594                         dctx.add("</div>\n")
 595                 end
 596
 597                 var op = new Buffer
 598                 op.append("digraph {name} \{ 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")
 599                 var ms = new Array[nullable MMModule]
 600                 do
 601                         var m0: nullable MMModule = self
 602                         while m0 != null do
 603                                 m0 = m0.direct_owner
 604                                 ms.add(m0)
 605                         end
 606                 end
 607                 var cla = new HashSet[MMModule]
 608                 cla.add(self)
 609                 for m0 in self.mhe.greaters do
 610                         if not m0.require_doc(dctx) then continue
 611                         if self.visibility_for(m0) <= 1 then continue # private or hidden
 612                         if self.mnhe <= m0 then continue # do not want nested stuff
 613                         if m0.direct_owner != null and not m0.direct_owner.mnhe <= self then continue # not in the right nesting
 614                         cla.add(m0)
 615                 end
 616                 for m0 in self.mhe.smallers do
 617                         if not m0.require_doc(dctx) then continue
 618                         if m0.visibility_for(self) <= 1 then continue # private or hidden
 619                         if m0.direct_owner != null and not m0.direct_owner.mnhe <= self then continue # not in the right nesting
 620                         cla.add(m0)
 621                 end
 622                 for m0 in self.mnhe.smallers do
 623                         cla.add(m0)
 624                 end
 625                 ms = ms.reversed
 626                 for m0 in ms do
 627                         if m0 != null then
 628                                 op.append("subgraph \"cluster_{m0.name}\"\{\n")
 629                         end
 630                         for c in cla do
 631                                 if c.direct_owner != m0 then continue
 632                                 if c == self then
 633                                         op.append("\"{c.name}\"[shape=box,margin=0.03];\n")
 634                                 else
 635                                         op.append("\"{c.name}\"[URL=\"{c.html_name}.html\"];\n")
 636                                 end
 637                         end
 638                         if m0 != null then
 639                                 op.append("\"{m0.name}\"[URL=\"{m0.html_name}.html\"];\n")
 640                                 for c in m0.mhe.direct_greaters do
 641                                         if not cla.has(c) then continue
 642                                         op.append("\"{m0.name}\"->\"{c.name}\";\n")
 643                                 end
 644                         end
 645                 end
 646                 for m0 in ms do
 647                         # Close the nesting subgraph
 648                         if m0 != null then
 649                                 op.append("\}\n")
 650                         end
 651                 end
 652                 for c in cla do
 653                         for c2 in c.tmhe.direct_greaters do
 654                                 if not cla.has(c2) then continue
 655                                 op.append("\"{c.name}\"->\"{c2.name}\";\n")
 656                         end
 657                 end
 658                 op.append("\}\n")
 659                 dctx.gen_dot(op.to_s, name.to_s, "Dependency graph for module {name}")
 660                 dctx.add("</section>")
 661
 662                 var clas = new Array[MMLocalClass]
 663                 var props = new HashMap[MMGlobalProperty, Array[MMLocalProperty]]
 664                 var gprops = new Array[MMLocalProperty]
 665                 do
 666                         var m = self
 667                         for g in m.global_classes do
 668                                 var lc = m[g]
 669                                 if not lc.require_doc(dctx) then continue
 670                                 var im = g.intro.mmmodule
 671                                 if self.visibility_for(im) <= 1 then continue # private import or invisible import
 672                                 var keep = false
 673                                 for lc2 in lc.crhe.greaters_and_self do
 674                                         if not lc2 isa MMSrcLocalClass then continue
 675                                         if not self.mnhe <= lc2.mmmodule then continue # not introduced/redefined here/stolen
 676                                         keep = true
 677                                 end
 678                                 if not keep then continue
 679                                 clas.add(self[g])
 680                                 lc.compute_super_classes
 681                                 for gp in lc.global_properties do
 682                                         if self.visibility_for(gp.intro.local_class.mmmodule) <= 1 then continue # private import or invisible import
 683                                         var lp = lc[gp]
 684                                         var mp = lp.local_class.mmmodule
 685                                         if not self.mnhe <= mp then continue # not introduced/redefined here/stolen
 686                                         lp = self[g][gp]
 687                                         if not lp.require_doc(dctx) then continue
 688                                         if props.has_key(lp.global) then
 689                                                 if not props[lp.global].has(lp) then
 690                                                         props[lp.global].add(lp)
 691                                                 end
 692                                         else
 693                                                 props[lp.global] = [lp]
 694                                                 gprops.add(lp.global.intro)
 695                                         end
 696                                 end
 697                         end
 698                 end
 699                 dctx.add("<section class=\"module\">\n")
 700                 dctx.open_stage
 701                 dctx.stage("<article class=\"classes filterable\">\n")
 702                 dctx.stage("<h2>Classes</h2>\n")
 703                 dctx.sort(clas)
 704                 dctx.stage("<ul>\n")
 705                 for lc in clas do
 706                         if self.mnhe <= lc.global.intro.mmmodule then
 707                                 dctx.add("<li class='intro'><span title='introduced in this module'>I</span>&nbsp;")
 708                         else
 709                                 dctx.add("<li class='redef'><span title='refined in this module'>R</span>&nbsp;")
 710                         end
 711                         dctx.add("{lc.html_link(dctx)}</li>\n")
 712                 end
 713                 dctx.stage("</ul></article>\n")
 714                 dctx.close_stage
 715
 716                 dctx.open_stage
 717                 dctx.stage("<article class=\"properties filterable\">\n")
 718                 dctx.stage("<h2>Properties</h2>\n")
 719                 dctx.sort(gprops)
 720                 dctx.stage("<ul>\n")
 721                 for lgp in gprops do
 722                         var gp = lgp.global
 723                         var lps = props[gp]
 724
 725                         if gp.intro isa MMAttribute then continue
 726
 727                         var lpi = self[gp.intro.local_class.global][gp]
 728
 729                         if lps.has(lpi) then
 730                                 dctx.add("<li class='intro'><span title='introduction in an other module'>I</span>&nbsp;{lpi.html_open_link(dctx)}{lpi.html_name}&nbsp;({lpi.local_class})</a></li>\n")
 731                                 lps.remove(lpi)
 732                         else
 733                                 dctx.add("<li class='intro'><span title='introduction in this module'>I</span>&nbsp;{lpi.html_name}")
 734                                 dctx.add("&nbsp;({lpi.local_class})</li>\n")
 735                         end
 736                         if lps.length >= 1 then
 737                                 dctx.sort(lps)
 738                                 for lp in lps do
 739                                         dctx.add("<li class='redef'><span title='redefinition'>R</span>&nbsp;{lp.html_open_link(dctx)}{lp.html_name}&nbsp;({lp.local_class})</a></li>")
 740                                 end
 741                         end
 742                 end
 743                 dctx.stage("</ul></article>\n")
 744                 dctx.close_stage
 745                 dctx.add("</section>\n")
 746                 dctx.add("</div>\n")
 747         end
 748
 749         # Fill the body for the page associated to the full index
 750         fun file_index_page_doc(dctx: DocContext)
 751         do
 752
 753                 dctx.add("<h1>Full Index</h1>\n")
 754
 755                 var clas = new Array[MMLocalClass]
 756                 var props = new HashMap[MMGlobalProperty, Array[MMLocalProperty]]
 757                 var gprops = new Array[MMLocalProperty]
 758                 var mods = new Array[MMModule]
 759                 for m in mhe.greaters_and_self do
 760                         if not m.require_doc(dctx) then continue
 761                         mods.add(m)
 762                 end
 763                 for g in global_classes do
 764                         var lc = self[g]
 765                         if not lc.require_doc(dctx) then continue
 766                         clas.add(lc)
 767                         for gp in lc.global_properties do
 768                                 var lp = lc[gp]
 769                                 if not lp.require_doc(dctx) then continue
 770                                 if props.has_key(lp.global) then
 771                                         if not props[lp.global].has(lp) then
 772                                                 props[lp.global].add(lp)
 773                                         end
 774                                 else
 775                                         props[lp.global] = [lp]
 776                                         gprops.add(lp.global.intro)
 777                                 end
 778                         end
 779                 end
 780                 dctx.open_stage
 781                 dctx.stage("<article class=\"modules filterable\">\n")
 782                 dctx.stage("<h2>Modules</h2>\n")
 783                 dctx.sort(mods)
 784                 dctx.stage("<ul>\n")
 785                 for m in mods do
 786                         dctx.add("<li>{m.html_link(dctx)}</li>")
 787                 end
 788                 dctx.stage("</ul></article>\n")
 789                 dctx.close_stage
 790
 791                 dctx.open_stage
 792                 dctx.stage("<article class=\"classes filterable\">\n")
 793                 dctx.stage("<h2>Classes</h2>\n")
 794                 dctx.sort(clas)
 795                 dctx.stage("<ul>\n")
 796                 for lc in clas do
 797                         dctx.add("<li>{lc.html_link(dctx)}</li>")
 798                 end
 799                 dctx.stage("</ul></article>\n")
 800                 dctx.close_stage
 801
 802                 dctx.open_stage
 803                 dctx.stage("<article class=\"properties filterable\">\n")
 804                 dctx.stage("<h2>Properties</h2>\n")
 805                 dctx.sort(gprops)
 806                 dctx.stage("<ul>\n")
 807                 for lgp in gprops do
 808                         var gp = lgp.global
 809                         var lps = props[gp]
 810
 811                         if gp.intro isa MMAttribute then continue
 812
 813                         var lpi = self[gp.intro.local_class.global][gp]
 814
 815                         lps.remove(lpi)
 816                                 dctx.add("<li class='intro'><span title='introduction'>I</span>&nbsp;{lpi.html_open_link(dctx)}{lpi.html_name}&nbsp;({lpi.local_class})</a></li>\n")
 817                         if lps.length >= 1 then
 818                                 dctx.sort(lps)
 819                                 for lp in lps do
 820                                         dctx.add("<li class='redef'><span title='redefinition'>R</span>&nbsp;{lp.html_open_link(dctx)}{lp.html_name}&nbsp;({lp.local_class})</a></li>\n")
 821                                 end
 822                         end
 823                 end
 824                 dctx.stage("</ul></article>\n")
 825                 dctx.close_stage
 826         end
 827
 828         # Fill the quicksearch list JSON object
 829         fun file_quicksearch_list_doc(dctx: DocContext)
 830         do
 831                 var entities = new HashMap[String, Array[MMEntity]]
 832                 var props = new HashMap[MMGlobalProperty, Array[MMLocalProperty]]
 833                 for m in mhe.greaters_and_self do
 834                         if not m.require_doc(dctx) then continue
 835                         var a = new Array[MMEntity]
 836                         a.add(m)
 837                         entities[m.html_name] = a
 838                 end
 839                 for g in global_classes do
 840                         var lc = self[g]
 841                         if not lc.require_doc(dctx) then continue
 842                         var a = new Array[MMEntity]
 843                         a.add(lc)
 844                         entities[lc.html_name] = a
 845                         for gp in lc.global_properties do
 846                                 var lp = lc[gp]
 847                                 if not lp.require_doc(dctx) then continue
 848                                 if props.has_key(lp.global) then
 849                                         if not props[lp.global].has(lp) then
 850                                                 props[lp.global].add(lp)
 851                                         end
 852                                 else
 853                                         props[lp.global] = [lp]
 854                                 end
 855                         end
 856                 end
 857
 858                 for k, v in props do
 859                         entities[k.short_name] = v
 860                 end
 861
 862                 var keys = entities.keys.to_a
 863                 var sorter = new AlphaSorter[String]
 864                 sorter.sort(keys)
 865
 866                 dctx.open_stage
 867                 dctx.stage("var entries = \{")
 868                 for key in keys do
 869                         dctx.add("\"{key}\": [")
 870                         for entity in entities[key] do
 871                                 dctx.add(entity.json_entry(dctx))
 872                         end
 873                         dctx.add("],")
 874                 end
 875                 dctx.stage("\};")
 876                 dctx.close_stage
 877         end
 878 end
 879
 880 redef class MMGlobalProperty
 881         # Return the short name of the property
 882         fun short_name: String do
 883                 return self.intro.html_name
 884         end
 885 end
 886
 887 redef class MMLocalProperty
 888         super MMEntity
 889         # Anchor of the property description in the module html file
 890         fun html_anchor: String
 891         do
 892                 return "PROP_{local_class}_{cmangle(name)}"
 893         end
 894
 895         redef fun json_entry(dctx) do
 896                 return "\{txt:\"{qualified_name}\",url:\"{local_class.html_name}.html#{html_anchor}\"\},"
 897         end
 898
 899         redef fun qualified_name do
 900                 return "{intro_module.qualified_name}::{local_class.html_name}::{html_name}"
 901         end
 902
 903         fun html_open_link(dctx: DocContext): String
 904         do
 905                 if not require_doc(dctx) then print "not required {self}"
 906                 var title = "{html_name}{signature.to_s}"
 907                 if short_doc != "&nbsp;" then
 908                         title += " #{short_doc}"
 909                 end
 910                 return "<a href=\"{local_class.html_name}.html#{html_anchor}\" title=\"{title}\">"
 911         end
 912
 913         fun html_name: String
 914         do
 915                 return self.name.to_s.html_escape
 916         end
 917
 918         redef fun html_link(dctx)
 919         do
 920                 if not require_doc(dctx) then print "not required {self}"
 921                 var title = "{html_name}{signature.to_s}"
 922                 if short_doc != "&nbsp;" then
 923                         title += " #{short_doc}"
 924                 end
 925                 return "<a href=\"{local_class.html_name}.html#{html_anchor}\" title=\"{title}\">{html_name}</a>"
 926         end
 927
 928         fun html_link_special(dctx: DocContext, lc: MMLocalClass): String
 929         do
 930                 if not require_doc(dctx) then print "not required {self}"
 931                 var title = "{html_name}{signature_for(lc.get_type)}"
 932                 if short_doc != "&nbsp;" then
 933                         title += " #{short_doc}"
 934                 end
 935                 return "<a href=\"{lc.html_name}.html#{html_anchor}\" title=\"{title}\">{html_name}</a>"
 936         end
 937
 938         # Kind of property (fun, attr, etc.)
 939         fun kind: String is abstract
 940
 941         redef fun short_doc
 942         do
 943                 var d = doc
 944                 if d != null then
 945                         return d.short
 946                 else if global.intro == self then
 947                         return "&nbsp;"
 948                 else
 949                         return global.intro.short_doc
 950                 end
 951         end
 952
 953         redef fun doc
 954         do
 955                 var n = node
 956                 if n == null or not n isa APropdef then
 957                         return null
 958                 end
 959                 var d = n.n_doc
 960                 if d == null then
 961                         return null
 962                 end
 963                 if d.n_comment.is_empty then
 964                         return null
 965                 else
 966                         return d
 967                 end
 968         end
 969
 970         # The most specific module in the nesting hierarchy that exports the intro of self
 971         fun intro_module: MMModule
 972         do
 973                 var m = global.intro.mmmodule
 974                 var mo = m.direct_owner
 975                 while mo != null and mo.visibility_for(m) >= 2 do
 976                         m = mo
 977                         mo = m.direct_owner
 978                 end
 979                 return m
 980         end
 981
 982         # Is the intro of self exported by the top-level module ?
 983         fun is_toplevel: Bool
 984         do
 985                 var m = intro_module
 986                 return m == m.toplevel_owner
 987         end
 988
 989         # Return true if the global property must be documented according to the visibility configured
 990         fun require_doc(dctx: DocContext): Bool
 991         do
 992                 if global.visibility_level == 3 and not dctx.with_private then return false # Private
 993                 if dctx.public_only then
 994                         var m = intro_module
 995                         if m != m.toplevel_owner then return false # Unexported
 996                 end
 997                 return true
 998         end
 999
1000         # Document the global property in the global class lc
1001         fun full_documentation(dctx: DocContext, lc: MMLocalClass)
1002         do
1003                 var visibility: String
1004                 if global.visibility_level == 1 then
1005                         visibility = "public"
1006                 else if global.visibility_level == 2 then
1007                         visibility = "protected"
1008                 else if global.visibility_level == 3 then
1009                         visibility = "private"
1010                 else
1011                         abort
1012                 end
1013
1014                 var intro_class = global.intro.local_class
1015                 var is_redef = local_class.global != intro_class.global or local_class.mmmodule.toplevel_owner != intro_class.mmmodule.toplevel_owner
1016
1017                 dctx.add("<article id=\"{html_anchor}\" class=\"{kind} {visibility} {if is_redef then "redef" else ""}\">\n")
1018                 dctx.add("<h3 class=\"signature\">{html_name}{signature.to_html(dctx, true)}</h3>\n")
1019                 dctx.add("<div class=\"info\">\n")
1020                 #dctx.add("<p>LP: {self.mmmodule.html_link(dctx)}::{self.local_class.html_link(dctx)}::{self.html_link(dctx)}</p>")
1021
1022                 if is_redef then
1023                         dctx.add("redef ")
1024                 end
1025                 if not is_toplevel then
1026                         dctx.add("(unexported) ")
1027                 end
1028                 if global.visibility_level == 2 then
1029                         dctx.add("protected ")
1030                 else if global.visibility_level == 3 then
1031                         dctx.add("private ")
1032                 end
1033                 dctx.add(kind)
1034                 dctx.add(" {intro_class.mmmodule.toplevel_owner.name}")
1035                 if intro_class.global == lc.global then
1036                         dctx.add("::{lc.name}")
1037                 else
1038                         dctx.add("::{mmmodule[intro_class.global].html_link(dctx)}")
1039                 end
1040                 if is_redef then
1041                         dctx.add("::{mmmodule[intro_class.global][global].html_link(dctx)}")
1042                 else
1043                         dctx.add("::{html_name}")
1044                 end
1045                 dctx.add("</div>")
1046
1047                 dctx.add("<div class=\"description\">")
1048
1049                 # Collect all refinement of the global property in the same global property
1050                 var lps = new Array[MMLocalProperty]
1051                 for l in prhe.greaters_and_self do
1052                         lps.add(l)
1053                 end
1054
1055                 var introdoc = false
1056                 if global.intro.doc != null then
1057                         for lp in lps do
1058                                 if lp.doc == null then introdoc = true
1059                         end
1060                 end
1061                 if introdoc then
1062                         dctx.add("<pre>{global.intro.doc.to_html}</pre>")
1063                 end
1064
1065                 var tlmods = new Array[MMModule]
1066                 for lp in lps do
1067                         var bm = lp.mmmodule.toplevel_owner
1068                         var lcm = lc.global.intro.mmmodule
1069                         if lcm.mhe < lp.mmmodule then bm = lcm.toplevel_owner
1070                         if not tlmods.has(bm) then tlmods.add(bm)
1071                 end
1072
1073                 for tm in tlmods do
1074                         # Document the top level property for the current top level module
1075                         var tlp
1076                         if tm.global_classes.has(lc.global) then
1077                                 tlp = tm[lc.global][self.global]
1078                                 assert lps.has(tlp)
1079                         else if tm.global_classes.has(self.local_class.global) then
1080                                 # Self is the inherited property. Process it
1081                                 tlp = tm[self.local_class.global][self.global]
1082                                 assert lps.has(tlp)
1083                         else
1084                                 # We skip this module since the props defined by the module is
1085                                 continue
1086                         end
1087
1088                         var tlcm = lc.global.intro.mmmodule.toplevel_owner
1089                         if not tlcm.mhe <= tm then
1090                                 dctx.add("<h4>In module {tm.html_link(dctx)} :</h4>")
1091                         end
1092
1093                         #dctx.add("<p>TLP: {tm} x {lc} : {tlp.full_name}</p>")
1094
1095                         var doc = tlp.doc
1096                         if doc != null and (not introdoc or global.intro.doc != doc) then
1097                                 dctx.add("<pre>{doc.to_html}</pre>")
1098                         end
1099                         dctx.add("<p>")
1100                         if tlp.local_class.global != lc.global then
1101                                 dctx.add("inherited from {tlp.local_class.html_link(dctx)} ")
1102                         end
1103                         if tm != tlp.mmmodule then
1104                                 dctx.add("defined by the module {tlp.mmmodule.html_link(dctx)} ")
1105                         end
1106                         var n = tlp.node
1107                         if n != null then
1108                                 var l = n.location
1109                                 dctx.show_source(l)
1110                         end
1111
1112                         dctx.open_stage
1113                         dctx.stage(". previously defined by:")
1114                         for lp in lps do
1115                                 var tl = lp.mmmodule.toplevel_owner
1116                                 if tl != tm then continue
1117                                 if lp == tlp then continue
1118                                 dctx.add(" {lp.mmmodule.html_link(dctx)}")
1119                                 if lp.local_class.global != lc.global then
1120                                         dctx.add(" for {lp.local_class.html_link(dctx)} ")
1121                                 end
1122
1123                                 n = lp.node
1124                                 if n != null then
1125                                         var l = n.location
1126                                         dctx.show_source(l)
1127                                 end
1128
1129                                 #var doc = lp.doc
1130                                 #if doc != null and (not introdoc or global.intro.doc != doc) then
1131                                 #       dctx.add("<pre>{doc.to_html}</pre>")
1132                                 #end
1133                         end
1134                         dctx.close_stage
1135                         dctx.add("</p>")
1136                 end
1137                 dctx.add("</div>")
1138                 dctx.add("</article>")
1139         end
1140 end
1141 redef class MMMethod
1142         redef fun kind do return if global.is_init then "init" else "fun"
1143 end
1144 redef class MMAttribute
1145         redef fun kind do return "var"
1146 end
1147 redef class MMTypeProperty
1148         redef fun kind do return "type"
1149 end
1150
1151 redef class MMSrcModule
1152         redef fun short_doc
1153         do
1154                 var d = doc
1155                 if d != null then
1156                         return d.short
1157                 else
1158                         return "&nbsp;"
1159                 end
1160         end
1161
1162         redef fun doc
1163         do
1164                 var n = node
1165                 if n.n_moduledecl == null then
1166                         return null
1167                 end
1168                 var np = n.n_moduledecl
1169                 var d = np.n_doc
1170                 if d == null then
1171                         return null
1172                 end
1173                 if d.n_comment.is_empty then
1174                         return null
1175                 else
1176                         return d
1177                 end
1178         end
1179 end
1180
1181 redef class ADoc
1182         # Html transcription of the doc
1183         fun to_html: String
1184         do
1185                 var res = new Buffer
1186                 for c in n_comment do
1187                         res.append(c.text.substring_from(1))
1188                 end
1189                 return res.to_s.html_escape
1190         end
1191
1192         # Oneliner transcription of the doc
1193         fun short: String
1194         do
1195                 return n_comment.first.text.substring_from(1).html_escape
1196         end
1197 end
1198
1199 redef class MMLocalClass
1200         super MMEntity
1201
1202         # Anchor of the class description in the module html file
1203         fun html_anchor: String do return "CLASS_{self}"
1204
1205         fun html_name: String do return "{self}"
1206
1207         redef fun html_link(dctx)
1208         do
1209                 if not require_doc(dctx) then print "{dctx.filename}: not required {self}"
1210                 return "<a href=\"{html_name}.html\" title=\"{short_doc}\">{self}</a>"
1211         end
1212
1213         redef fun json_entry(dctx) do
1214                 return "\{txt:\"{qualified_name}\",url:\"{html_name}.html\"\},"
1215         end
1216
1217         redef fun qualified_name do
1218                 return "{intro_module.qualified_name}::{html_name}"
1219         end
1220
1221         redef fun short_doc do return global.intro.short_doc
1222
1223         redef fun doc do return global.intro.doc
1224
1225         fun kind: String
1226         do
1227                 if global.is_interface then
1228                         return "interface"
1229                 else if global.is_abstract then
1230                         return "abstract class"
1231                 else if global.is_enum then
1232                         return "enum"
1233                 else
1234                         return "class"
1235                 end
1236         end
1237
1238         # The most specific module in the nesting hierarchy that exports the intro of self
1239         fun intro_module: MMModule
1240         do
1241                 var m = global.intro.mmmodule
1242                 var mo = m.direct_owner
1243                 while mo != null and mo.visibility_for(m) >= 2 do
1244                         m = mo
1245                         mo = m.direct_owner
1246                 end
1247                 return m
1248         end
1249
1250         fun menu_link(dctx: DocContext, p: MMLocalProperty)
1251         do
1252                 if p.local_class.global != self.global then
1253                         if p.global.intro.local_class.name == "Object".to_symbol then return
1254                         if p.global.is_init or p isa MMTypeProperty then
1255                                 dctx.add("<li class='inherit'><span title='Inherited'>H</span>&nbsp;{p.html_link_special(dctx, self)}</li>\n")
1256                         else
1257                                 dctx.add("<li class='inherit'><span title='Inherited'>H</span>&nbsp;{p.html_link(dctx)}</li>\n")
1258                         end
1259                 else if p.global.intro.local_class.global == self.global then
1260                         dctx.add("<li class='intro'><span title='Introduced'>I</span>&nbsp;{p.html_link_special(dctx, self)}</li>\n")
1261                 else
1262                         dctx.add("<li class='redef'><span title='Redefined'>R</span>&nbsp;{p.html_link_special(dctx, self)}</li>\n")
1263                 end
1264         end
1265
1266         # Return true if the global class must be documented according to the visibility configured
1267         fun require_doc(dctx: DocContext): Bool
1268         do
1269                 if global.visibility_level == 3 and not dctx.with_private then return false # Private
1270                 if dctx.public_only then
1271                         var m = intro_module
1272                         if m != m.toplevel_owner then return false # Unexported
1273                 end
1274                 return true
1275         end
1276
1277         # Fill the body for the page associated to the global class
1278         fun file_page_doc(dctx: DocContext)
1279         do
1280                 dctx.add("<div class=\"menu\">\n")
1281
1282                 var props = new Array[MMLocalProperty]
1283                 var inh = new HashMap[MMLocalClass, Array[MMLocalProperty]]
1284                 var inhs = new Array[MMLocalClass]
1285                 for g in global_properties do
1286                         var p = self[g]
1287                         if not p.require_doc(dctx) then continue
1288                         if p.local_class.global == global or g.is_init_for(self) or p isa MMTypeProperty then
1289                                 props.add(p)
1290                         else
1291                                 var lc = mmmodule[p.local_class.global]
1292                                 if inh.has_key(lc) then
1293                                         inh[lc].add(p)
1294                                 else
1295                                         inh[lc] = [p]
1296                                         inhs.add(lc)
1297                                 end
1298                                 props.add(p)
1299                         end
1300                 end
1301                 dctx.sort(props)
1302
1303                 dctx.add("<nav class=\"properties filterable\">\n")
1304                 dctx.add("<h3>Properties</h3>\n")
1305                 dctx.open_stage
1306                 dctx.stage("<h4>Virtual Types</h4>\n<ul>\n")
1307                 for p in props do
1308                         if p isa MMTypeProperty then
1309                                 menu_link(dctx, p)
1310                         end
1311                 end
1312                 dctx.stage("</ul>\n")
1313                 dctx.close_stage
1314                 dctx.open_stage
1315                 dctx.stage("<h4>Constructors</h4>\n<ul>\n")
1316                 for p in props do
1317                         if p.global.is_init_for(self) then
1318                                 menu_link(dctx, p)
1319                         end
1320                 end
1321                 dctx.stage("</ul>\n")
1322                 dctx.close_stage
1323                 dctx.open_stage
1324                 dctx.stage("<h4>Methods</h4>\n<ul>\n")
1325                 for p in props do
1326                         if not p.global.is_init and p isa MMMethod then
1327                                 menu_link(dctx, p)
1328                         end
1329                 end
1330                 dctx.stage("</ul>\n")
1331                 dctx.close_stage
1332                 dctx.add("</nav>\n")
1333
1334                 dctx.add("<nav class=\"inheritance filterable\">\n")
1335                 dctx.add("<h3>Inheritance</h3>\n")
1336                 dctx.add("<h4>Superclasses</h4>\n<ul>\n")
1337                 for lc in cshe.linear_extension do
1338                         if lc == self then continue
1339                         if not lc.require_doc(dctx) then continue
1340                         dctx.add("<li>{lc.html_link(dctx)}</li>\n")
1341                 end
1342                 dctx.add("</ul>\n")
1343                 if cshe.smallers.length == 0 then
1344                         dctx.add("<h4>No Known Subclasses</h4>\n")
1345                 else if cshe.smallers.length <= 100 then
1346                         dctx.add("<h4>Subclasses</h4>\n")
1347                         dctx.add("<ul>\n")
1348                         for lc in cshe.smallers do
1349                                 if not lc.require_doc(dctx) then continue
1350                                 dctx.add("<li>{lc.html_link(dctx)}</li>\n")
1351                         end
1352                         dctx.add("</ul>\n")
1353                 else if cshe.direct_smallers.length <= 100 then
1354                         dctx.add("<h4>Direct Subclasses Only</h4>\n<ul>\n")
1355                         for lc in cshe.direct_smallers do
1356                                 if not lc.require_doc(dctx) then continue
1357                                 dctx.add("<li>{lc.html_link(dctx)}</li>\n")
1358                         end
1359                         dctx.add("</ul>\n")
1360                 else
1361                         dctx.add("<h4>Too much Subclasses to list</h4>\n")
1362                 end
1363                 dctx.add("</nav>\n")
1364
1365                 dctx.add("</div>\n")
1366
1367
1368                 dctx.add("<div class=\"content\">\n")
1369                 dctx.add("<h1>{name}</h1>\n")
1370                 dctx.add("<div class='subtitle'>")
1371                 if global.visibility_level == 2 then
1372                         abort
1373                 else if global.visibility_level == 3 then
1374                         dctx.add("private ")
1375                 else if self.global.intro.mmmodule.toplevel_owner.visibility_for(self.global.intro.mmmodule) <= 1 then
1376                         dctx.add("(unexported) ")
1377                 end
1378                 dctx.add("{kind} {global.intro.mmmodule.toplevel_owner.html_link(dctx)}::{name}</div>")
1379
1380                 dctx.add("<section class=\"description\">\n")
1381                 var doc = doc
1382                 if doc != null then
1383                         dctx.add("<pre>{doc.to_html}</pre>\n")
1384                 end
1385
1386                 var cla = new HashSet[MMLocalClass]
1387                 var sm = new HashSet[MMLocalClass]
1388                 var sm2 = new HashSet[MMLocalClass]
1389                 sm.add(self)
1390                 while cla.length + sm.length < 10 and sm.length > 0 do
1391                         cla.add_all(sm)
1392                         sm2.clear
1393                         for x in sm do
1394                                 sm2.add_all(x.cshe.direct_smallers)
1395                         end
1396                         var t = sm
1397                         sm = sm2
1398                         sm2 = t
1399                 end
1400                 cla.add_all(cshe.greaters_and_self)
1401
1402                 var op = new Buffer
1403                 var name = "class_{name}"
1404                 op.append("digraph {name} \{ 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")
1405                 for c in cla do
1406                         if c == self then
1407                                 op.append("\"{c.name}\"[shape=box,margin=0.03];\n")
1408                         else
1409                                 op.append("\"{c.name}\"[URL=\"{c.html_name}.html\"];\n")
1410                         end
1411                         for c2 in c.cshe.direct_greaters do
1412                                 if not cla.has(c2) then continue
1413                                 op.append("\"{c.name}\"->\"{c2.name}\";\n")
1414                         end
1415                         if not c.cshe.direct_smallers.is_empty then
1416                                 var others = true
1417                                 for c2 in c.cshe.direct_smallers do
1418                                         if cla.has(c2) then others = false
1419                                 end
1420                                 if others then
1421                                         op.append("\"{c.name}...\"[label=\"\"];\n")
1422                                         op.append("\"{c.name}...\"->\"{c.name}\"[style=dotted];\n")
1423                                 end
1424                         end
1425                 end
1426                 op.append("\}\n")
1427                 dctx.gen_dot(op.to_s, name.to_s, "Inheritance graph for class {name}")
1428
1429
1430                 var mods = new Array[MMModule]
1431                 mods.add(global.intro.mmmodule.toplevel_owner)
1432                 for lc in crhe.greaters do
1433                         if not lc isa MMSrcLocalClass then continue
1434                         var m = lc.mmmodule.toplevel_owner
1435                         if not mods.has(m) then mods.add(m)
1436                 end
1437                 dctx.sort(mods)
1438                 for m in mods do
1439                         if m == global.intro.mmmodule.toplevel_owner then
1440                                 dctx.add("<p>Introduced by {m.html_link(dctx)}")
1441                         else
1442                                 dctx.add("<p>Refined by {m.html_link(dctx)}")
1443                         end
1444                         dctx.open_stage
1445                         dctx.stage(". Definition in:")
1446                         for lc in crhe.greaters do
1447                                 if lc.mmmodule.toplevel_owner != m then continue
1448                                 dctx.add(" {lc.mmmodule.html_link(dctx)} ")
1449                                 assert lc isa MMSrcLocalClass
1450                                 var n = lc.node
1451                                 if n != null then
1452                                         dctx.show_source(n.location)
1453                                 end
1454                         end
1455                         dctx.close_stage
1456                         dctx.add("</p>\n")
1457                 end
1458                 dctx.add("</section>\n")
1459
1460                 dctx.open_stage
1461                 dctx.stage("<section class=\"types\">\n")
1462                 dctx.stage("<h2>Formal and Virtual Types</h2>\n")
1463                 for i in [0..arity[ do
1464                         var f = get_formal(i)
1465                         f.full_documentation(dctx, self)
1466                 end
1467                 for p in props do
1468                         if not p isa MMTypeProperty then continue
1469                         p.full_documentation(dctx, self)
1470                 end
1471                 dctx.stage("</section>\n")
1472                 dctx.close_stage
1473
1474                 dctx.open_stage
1475                 dctx.stage("<section class=\"constructors\">\n")
1476                 dctx.stage("<h2 class=\"section-header\">Constructors</h2>\n")
1477                 for p in props do
1478                         if not p.global.is_init_for(self) then continue
1479                         p.full_documentation(dctx, self)
1480                 end
1481                 dctx.stage("</section>\n")
1482                 dctx.close_stage
1483
1484                 dctx.open_stage
1485                 dctx.stage("<section class=\"methods\">\n")
1486                 dctx.stage("<h2 class=\"section-header\">Methods</h2>\n")
1487                 for p in props do
1488                         if p.global.is_init then continue
1489                         if p.local_class.global != self.global then continue
1490                         if not p isa MMMethod then continue
1491                         p.full_documentation(dctx, self)
1492                 end
1493                 if not inhs.is_empty then
1494                         dctx.open_stage
1495                         dctx.stage("<h3>Inherited Methods</h3>\n")
1496                         for lc in inhs do
1497                                 dctx.open_stage
1498                                 dctx.stage("<p>Defined in {lc.html_link(dctx)}:")
1499                                 for p in inh[lc] do
1500                                         if p.global.is_init then continue
1501                                         if not p isa MMMethod then continue
1502                                         dctx.add(" {p.html_link(dctx)}")
1503                                 end
1504                                 dctx.stage("</p>")
1505                                 dctx.close_stage
1506                         end
1507                         dctx.close_stage
1508                 end
1509                 dctx.add("</section>\n")
1510                 dctx.close_stage
1511                 dctx.add("</div> <!-- end class {name} -->\n")
1512         end
1513 end
1514
1515 redef class MMSrcLocalClass
1516         redef fun short_doc
1517         do
1518                 var d = doc
1519                 if d != null then
1520                         return d.short
1521                 else if global.intro == self then
1522                         return "&nbsp;"
1523                 else
1524                         var bc = global.intro
1525                         return bc.short_doc
1526                 end
1527         end
1528
1529         redef fun doc
1530         do
1531                 var n = node
1532                 if not n isa AStdClassdef then
1533                         return null
1534                 end
1535                 var d = n.n_doc
1536                 if d == null then
1537                         return null
1538                 end
1539                 if d.n_comment.is_empty then
1540                         return null
1541                 else
1542                         return d
1543                 end
1544         end
1545 end
1546
1547 redef class MMSignature
1548         # Htlm transcription of the signature (with nested links)
1549         fun to_html(dctx: DocContext, with_closure: Bool): String
1550         do
1551                 var res = new Buffer
1552                 if arity > 0 then
1553                         res.append("(")
1554                         for i in [0..arity[ do
1555                                 if i > 0 then res.append(", ")
1556                                 res.append(self.params[i].name.to_s)
1557                                 res.append(": ")
1558                                 res.append(self[i].html_link(dctx))
1559                                 if self.vararg_rank == i then
1560                                         res.append("...")
1561                                 end
1562                         end
1563                         res.append(")")
1564                 end
1565                 if return_type != null then
1566                         res.append(": ")
1567                         res.append(return_type.html_link(dctx))
1568                 end
1569                 if with_closure then
1570                         for c in closures do
1571                                 res.append(" ")
1572                                 if c.is_optional then res.append("[")
1573                                 if c.is_break then res.append("break ")
1574                                 res.append("!{c.name}")
1575                                 res.append(c.signature.to_html(dctx, false))
1576                                 if c.is_optional then res.append("]")
1577                         end
1578                 end
1579                 return res.to_s
1580         end
1581 end
1582
1583 redef class MMType
1584         # Htlm transcription of the type (with nested links)
1585         fun html_link(dctx: DocContext): String do return to_s
1586 end
1587
1588 redef class MMTypeSimpleClass
1589         redef fun html_link(dctx) do return local_class.html_link(dctx)
1590 end
1591
1592 redef class MMTypeGeneric
1593         redef fun html_link(dctx)
1594         do
1595                 var res = new Buffer
1596                 res.append(local_class.html_link(dctx))
1597                 res.append("[")
1598                 res.append(params[0].html_link(dctx))
1599                 for i in [1..params.length[ do
1600                         res.append(", ")
1601                         res.append(params[i].html_link(dctx))
1602                 end
1603                 res.append("]")
1604                 return res.to_s
1605         end
1606 end
1607
1608 redef class MMTypeFormalParameter
1609         fun html_anchor: String
1610         do
1611                 return "FT_{local_class}_{cmangle(name)}"
1612         end
1613         redef fun html_link(dctx)
1614         do
1615                 return "<a href=\"#{html_anchor}\">{name}</a>"
1616         end
1617         fun full_documentation(dctx: DocContext, lc: MMLocalClass)
1618         do
1619                 dctx.add("<article id=\"{html_anchor}\">\n")
1620                 dctx.add("<h3 class=\"signature\">{name}: {bound.html_link(dctx)}</h3>\n")
1621                 dctx.add("<div class=\"info\">")
1622                 dctx.add("formal generic type")
1623                 dctx.add("</div>")
1624                 dctx.add("</article>")
1625         end
1626 end
1627
1628 redef class MMNullableType
1629         redef fun html_link(dctx) do return "nullable " + as_notnull.html_link(dctx)
1630 end
1631
1632 redef class MMVirtualType
1633         redef fun html_link(dctx) do return property.html_link(dctx)
1634 end
1635
1636 var c = new DocContext
1637 c.exec_cmd_line