neo_doxygen: Remove an old TODO.

[nit.git] / contrib / neo_doxygen / src / neo_doxygen.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Doxygen XML to Neo4j.
#
# Converts a Doxygen XML output into a model in Neo4j that is readable by the
# `nx` tool.
module neo_doxygen

import model
import doxml
import console
import opts

# An importation task.
class NeoDoxygenJob
        var client: Neo4jClient
        var model: ProjectGraph is noinit

        # How many operation can be executed in one batch?
        private var batch_max_size = 1000

        private var save_cursor: String = (new TermSaveCursor).to_s

        # Escape control sequence to reset the current line.
        private var reset_line: String = "{new TermRestoreCursor}{new TermEraseDisplayDown}"

        # Generate a graph from the specified project model.
        #
        # Parameters:
        #
        # * `name`: project name.
        # * `dir`: Doxygen XML output directory path.
        # * `source`: The language-specific logics to use.
        fun load_project(name: String, dir: String, source: SourceLanguage) do
                check_name name
                model = new ProjectGraph(name)
                var reader = new CompoundFileReader(model, source)
                # Queue for sub-directories.
                var directories = new Array[String]
                var file_count = 0

                if dir == "" then
                        sys.stdout.write "Reading the current directory... "
                else
                        sys.stdout.write "Reading {dir}... "
                end
                loop
                        for f in dir.files do
                                var path = dir/f
                                if path.file_stat.is_dir then
                                        directories.push(path)
                                else if f.has_suffix(".xml") and f != "index.xml" then
                                        reader.read(path)
                                        file_count += 1
                                end
                        end
                        if directories.length <= 0 then break
                        dir = directories.pop
                end
                print "Done."
                if file_count < 2 then
                        print "{file_count} file read."
                else
                        print "{file_count} files read."
                end
        end

        # Check the project’s name.
        private fun check_name(name: String) do
                assert name_valid: not name.chars.first.is_upper else
                        sys.stderr.write("{sys.program_name}: The project’s name must not" +
                                        " begin with an upper case letter. Got `{name}`.\n")
                end
                var query = new CypherQuery.from_string("match n where \{name\} in labels(n) return count(n)")
                query.params["name"] = name
                var data = client.cypher(query).as(JsonObject)["data"]
                var result = data.as(JsonArray).first.as(JsonArray).first.as(Int)
                assert name_unused: result == 0 else
                        sys.stderr.write("{sys.program_name}: The label `{name}` is already" +
                        " used in the specified graph.\n")
                end
        end

        # Save the graph.
        fun save do
                sys.stdout.write "Linking nodes...{save_cursor} "
                model.put_edges
                print "{reset_line} Done."
                var nodes = model.all_nodes
                sys.stdout.write "Saving {nodes.length} nodes...{save_cursor} "
                push_all(nodes)
                var edges = model.all_edges
                sys.stdout.write "Saving {edges.length} edges...{save_cursor} "
                push_all(edges)
        end

        # Save `neo_entities` in the database using batch mode.
        private fun push_all(neo_entities: Collection[NeoEntity]) do
                var batch = new NeoBatch(client)
                var len = neo_entities.length
                var sum = 0
                var i = 1

                for nentity in neo_entities do
                        batch.save_entity(nentity)
                        if i == batch_max_size then
                                do_batch(batch)
                                sum += batch_max_size
                                sys.stdout.write("{reset_line} {sum * 100 / len}% ")
                                batch = new NeoBatch(client)
                                i = 1
                        else
                                i += 1
                        end
                end
                do_batch(batch)
                print("{reset_line} Done.")
        end

        # Execute `batch` and check for errors.
        #
        # Abort if `batch.execute` returns errors.
        private fun do_batch(batch: NeoBatch) do
                var errors = batch.execute
                if not errors.is_empty then
                        for e in errors do sys.stderr.write("{sys.program_name}: {e}\n")
                        exit(1)
                end
        end
end

# The main class.
class NeoDoxygenCommand

        # Invalid arguments
        var e_usage = 64

        # Available options for `--src-lang`.
        var sources = new HashMap[String, SourceLanguage]

        # The synopsis.
        var synopsis: String = "[--dest <url>] [--src-lang <lang>]\n" +
                        "    [--] <project_name> <doxml_dir>"

        # The synopsis for the help page.
        var help_synopsis = "[-h|--help]"

        # The default destination.
        var default_dest = "http://localhost:7474"

        # Processes the options.
        var option_context = new OptionContext

        # The `--src-lang` option.
        var opt_src_lang: OptionEnum is noinit

        # The `--dest` option.
        var opt_dest: OptionString is noinit

        # The `-h|--help` option.
        var opt_help: OptionBool is noinit

        init do
                sources["any"] = new DefaultSource
                sources["java"] = new JavaSource

                var prefix = new OptionText("""
{{{"NAME".bold}}}
  {{{sys.program_name}}} — Doxygen XML to Neo4j.

{{{"SYNOPSIS".bold}}}
  {{{sys.program_name}}} {{{synopsis}}}
  {{{sys.program_name}}} {{{help_synopsis}}}

{{{"DESCRIPTION".bold}}}
  Convert a Doxygen XML output into a model in Neo4j that is readable by the
  `nx` tool.

{{{"ARGUMENTS".bold}}}
  <project_name>  The internal name of the project. Must the same name as the
                  one specified to the `nx` tool. Must not begin by an upper
                  case letter.

  <doxml_dir>     The directory where the XML documents generated by Doxygen are
                  located.

{{{"OPTIONS".bold}}}
""")
                option_context.add_option(prefix)

                opt_dest = new OptionString("The URL of the destination graph. `{default_dest}` by default.",
                                "--dest")
                opt_dest.default_value = default_dest
                option_context.add_option(opt_dest)

                opt_help = new OptionBool("Show the help (this page).",
                                "-h", "--help")
                option_context.add_option(opt_help)

                var keys = new Array[String].from(sources.keys)
                opt_src_lang = new OptionEnum(keys,
                                "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.",
                                keys.index_of("any"), "--src-lang")
                option_context.add_option(opt_src_lang)
        end

        # Start the application.
        fun main: Int do
                if args.is_empty then
                        show_help
                        return e_usage
                end
                option_context.parse(args)

                var errors = option_context.get_errors
                var rest = option_context.rest

                if errors.is_empty and not opt_help.value and rest.length != 2 then
                        errors.add "Unexpected number of additional arguments. Expecting 2; got {rest.length}."
                end
                if not errors.is_empty then
                        for e in errors do print_error(e)
                        show_usage
                        return e_usage
                end
                if opt_help.value then
                        show_help
                        return 0
                end

                var source = sources[opt_src_lang.value_name]
                var dest = opt_dest.value
                var project_name = rest[0]
                var dir = rest[1]
                var neo = new NeoDoxygenJob(new Neo4jClient(dest or else default_dest))

                neo.load_project(project_name, dir, source)
                neo.save
                return 0
        end

        # Show the help.
        fun show_help do
                option_context.usage
        end

        # Show the usage.
        fun show_usage do
                sys.stderr.write "Usage: {sys.program_name} {synopsis}\n"
                sys.stderr.write "For details, run `{sys.program_name} --help`.\n"
        end

        # Print an error.
        fun print_error(e: String) do
                sys.stderr.write "{sys.program_name}: {e}\n"
        end
end

# Add handling of multi-line descriptions.
#
# Note: The algorithm is naive and do not handle internationalisation and
# escape sequences.
redef class Option

        redef fun pretty(off) do
                var s = super

                if s.length > 80 and off < 80 then
                        var column_length = 80 - off
                        var left = 0
                        var right = 80
                        var buf = new FlatBuffer
                        var prefix = "\n{" " * off}"

                        loop
                                while right > left and s.chars[right] != ' ' do
                                        right -= 1
                                end
                                if left == right then
                                        buf.append s.substring(left, column_length)
                                        right += column_length
                                else
                                        buf.append s.substring(left, right - left)
                                        right += 1
                                end
                                buf.append prefix
                                left = right
                                right += column_length
                                if right >= s.length then break
                        end
                        buf.append s.substring_from(left)
                        buf.append "\n"
                        return buf.to_s
                else
                        return "{s}\n"
                end
        end
end

exit((new NeoDoxygenCommand).main)