contrib/neo_doxygen/src/neo_doxygen.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 # Doxygen XML to Neo4j.
  16 #
  17 # Converts a Doxygen XML output into a model in Neo4j that is readable by the
  18 # `nx` tool.
  19 module neo_doxygen
  20
  21 import model
  22 import doxml
  23 import graph_store
  24 import console
  25 import opts
  26
  27 # An importation task.
  28 class NeoDoxygenJob
  29
  30         # The storage medium to use.
  31         var store: GraphStore
  32
  33         # The loaded project graph.
  34         var model: ProjectGraph is noinit
  35
  36         # Escape control sequence to save the cursor position.
  37         private var term_save_cursor: String = (new TermSaveCursor).to_s
  38
  39         # Escape control sequence to rewind to the last saved cursor position.
  40         private var term_rewind: String = "{new TermRestoreCursor}{new TermEraseDisplayDown}"
  41
  42         # Generate a graph from the specified project model.
  43         #
  44         # Parameters:
  45         #
  46         # * `name`: project name.
  47         # * `dir`: Doxygen XML output directory path.
  48         # * `source`: The language-specific logics to use.
  49         fun load_project(name: String, dir: String, source: SourceLanguage) do
  50                 check_name name
  51                 model = new ProjectGraph(name)
  52                 var reader = new CompoundFileReader(model, source)
  53                 # Queue for sub-directories.
  54                 var directories = new Array[String]
  55                 var file_count = 0
  56
  57                 if dir == "" then
  58                         printn "Reading the current directory... "
  59                 else
  60                         printn "Reading {dir}... "
  61                 end
  62                 loop
  63                         for f in list_files(dir) do
  64                                 var path = dir/f
  65                                 if path.file_stat.is_dir then
  66                                         directories.push(path)
  67                                 else if f.has_suffix(".xml") and f != "index.xml" then
  68                                         reader.read(path)
  69                                         file_count += 1
  70                                 end
  71                         end
  72                         if directories.length <= 0 then break
  73                         dir = directories.pop
  74                 end
  75                 model.add_global_modules
  76                 print "Done."
  77                 if file_count < 2 then
  78                         print "{file_count} file read."
  79                 else
  80                         print "{file_count} files read."
  81                 end
  82         end
  83
  84         # List files in a directory.
  85         #
  86         # This method may be redefined to force the order in which the files
  87         # are read by `load_project`.
  88         protected fun list_files(dir: String): Collection[String] do
  89                 return dir.files
  90         end
  91
  92         # Check the project’s name.
  93         private fun check_name(name: String) do
  94                 assert name_valid: not name.chars.first.is_upper else
  95                         sys.stderr.write("{sys.program_name}: The project’s name must not" +
  96                                         " begin with an upper case letter. Got `{name}`.\n")
  97                 end
  98                 assert name_unused: not store.has_node_label(name) else
  99                         sys.stderr.write("{sys.program_name}: The label `{name}` is already" +
 100                         " used in the specified graph.\n")
 101                 end
 102         end
 103
 104         # Save the graph.
 105         fun save do
 106                 sys.stdout.write "Linking nodes...{term_save_cursor} "
 107                 model.put_edges
 108                 print "{term_rewind} Done."
 109                 var nodes = model.all_nodes
 110                 sys.stdout.write "Saving {nodes.length} nodes..."
 111                 store.save_all(nodes)
 112                 var edges = model.all_edges
 113                 sys.stdout.write "Saving {edges.length} edges..."
 114                 store.save_all(edges)
 115         end
 116 end
 117
 118 # The main class.
 119 class NeoDoxygenCommand
 120
 121         # Invalid arguments
 122         var e_usage = 64
 123
 124         # Available options for `--src-lang`.
 125         var sources = new HashMap[String, SourceLanguage]
 126
 127         # The synopsis.
 128         var synopsis: String = "[--dest <url>] [--src-lang <lang>]\n" +
 129                         "    [--] <project_name> <doxml_dir>"
 130
 131         # The synopsis for the help page.
 132         var help_synopsis = "[-h|--help]"
 133
 134         # The default destination.
 135         var default_dest = "http://localhost:7474"
 136
 137         # Processes the options.
 138         var option_context = new OptionContext
 139
 140         # The `--src-lang` option.
 141         var opt_src_lang: OptionEnum is noinit
 142
 143         # The `--dest` option.
 144         var opt_dest: OptionString is noinit
 145
 146         # The `-h|--help` option.
 147         var opt_help: OptionBool is noinit
 148
 149         init do
 150                 sources["any"] = new DefaultSource
 151                 sources["java"] = new JavaSource
 152
 153                 var prefix = new OptionText("""
 154 {{{"NAME".bold}}}
 155   {{{sys.program_name}}} — Doxygen XML to Neo4j.
 156
 157 {{{"SYNOPSIS".bold}}}
 158   {{{sys.program_name}}} {{{synopsis}}}
 159   {{{sys.program_name}}} {{{help_synopsis}}}
 160
 161 {{{"DESCRIPTION".bold}}}
 162   Convert a Doxygen XML output into a model in Neo4j that is readable by the
 163   `nx` tool.
 164
 165 {{{"ARGUMENTS".bold}}}
 166   <project_name>  The internal name of the project. Must the same name as the
 167                   one specified to the `nx` tool. Must not begin by an upper
 168                   case letter.
 169
 170   <doxml_dir>     The directory where the XML documents generated by Doxygen are
 171                   located.
 172
 173 {{{"OPTIONS".bold}}}
 174 """)
 175                 option_context.add_option(prefix)
 176
 177                 opt_dest = new OptionString("The URL of the destination graph. `{default_dest}` by default.",
 178                                 "--dest")
 179                 opt_dest.default_value = default_dest
 180                 option_context.add_option(opt_dest)
 181
 182                 opt_help = new OptionBool("Show the help (this page).",
 183                                 "-h", "--help")
 184                 option_context.add_option(opt_help)
 185
 186                 var keys = new Array[String].from(sources.keys)
 187                 opt_src_lang = new OptionEnum(keys,
 188                                 "The programming language to assume when processing chunk in the declarations left as-is by Doxygen. Use `any` (the default) to disable any language-specific processing.",
 189                                 keys.index_of("any"), "--src-lang")
 190                 option_context.add_option(opt_src_lang)
 191         end
 192
 193         # Start the application.
 194         fun main: Int do
 195                 if args.is_empty then
 196                         show_help
 197                         return e_usage
 198                 end
 199                 option_context.parse(args)
 200
 201                 var errors = option_context.get_errors
 202                 var rest = option_context.rest
 203
 204                 if errors.is_empty and not opt_help.value and rest.length != 2 then
 205                         errors.add "Unexpected number of additional arguments. Expecting 2; got {rest.length}."
 206                 end
 207                 if not errors.is_empty then
 208                         for e in errors do print_error(e)
 209                         show_usage
 210                         return e_usage
 211                 end
 212                 if opt_help.value then
 213                         show_help
 214                         return 0
 215                 end
 216
 217                 var source = sources[opt_src_lang.value_name]
 218                 var dest = opt_dest.value
 219                 var project_name = rest[0]
 220                 var dir = rest[1]
 221                 var neo = new NeoDoxygenJob(create_store(dest or else default_dest))
 222
 223                 neo.load_project(project_name, dir, source)
 224                 neo.save
 225                 return 0
 226         end
 227
 228         # Create an instance of `GraphStore` for the specified destination.
 229         protected fun create_store(dest: String): GraphStore do
 230                 return new Neo4jStore(new Neo4jClient(dest))
 231         end
 232
 233         # Show the help.
 234         fun show_help do
 235                 option_context.usage
 236         end
 237
 238         # Show the usage.
 239         fun show_usage do
 240                 sys.stderr.write "Usage: {sys.program_name} {synopsis}\n"
 241                 sys.stderr.write "For details, run `{sys.program_name} --help`.\n"
 242         end
 243
 244         # Print an error.
 245         fun print_error(e: String) do
 246                 sys.stderr.write "{sys.program_name}: {e}\n"
 247         end
 248 end
 249
 250 # Add handling of multi-line descriptions.
 251 #
 252 # Note: The algorithm is naive and do not handle internationalisation and
 253 # escape sequences.
 254 redef class Option
 255
 256         redef fun pretty(off) do
 257                 var s = super
 258
 259                 if s.length > 80 and off < 80 then
 260                         var column_length = 80 - off
 261                         var left = 0
 262                         var right = 80
 263                         var buf = new FlatBuffer
 264                         var prefix = "\n{" " * off}"
 265
 266                         loop
 267                                 while right > left and s.chars[right] != ' ' do
 268                                         right -= 1
 269                                 end
 270                                 if left == right then
 271                                         buf.append s.substring(left, column_length)
 272                                         right += column_length
 273                                 else
 274                                         buf.append s.substring(left, right - left)
 275                                         right += 1
 276                                 end
 277                                 buf.append prefix
 278                                 left = right
 279                                 right += column_length
 280                                 if right >= s.length then break
 281                         end
 282                         buf.append s.substring_from(left)
 283                         buf.append "\n"
 284                         return buf.to_s
 285                 else
 286                         return "{s}\n"
 287                 end
 288         end
 289 end
 290
 291 exit((new NeoDoxygenCommand).main)