[nit.git] / src / doc / commands / commands_model.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.

# Doc commands about a Model or a MEntity
#
# This module defines several commands to retrieve data about a Model and MEntities.
module commands_model

import commands_base

import model::model_collect
import modelize
import modelbuilder
import htmlight
import doc_down

# Retrieve the MDoc related to a MEntity
class CmdComment
        super CmdEntity

        # Allow fallback
        #
        # If `true`, the command uses `mdoc_or_fallback`.
        # Default is `true`.
        var fallback = true is optional, writable

        # Retrieve the full documentation
        #
        # If `true`, retrieves the full documentation.
        # If `false`, retrieves only the synopsis.
        # Default is `true`.
        #
        # Since the rendering the final string (md, html...) depends on the kind of
        # client, the handling of this option is delegated to submodules.
        var full_doc = true is optional, writable

        # Format to render the comment
        #
        # Can be one of `raw` or `html`.
        # Default is `raw`.
        var format = "raw" is optional, writable

        # MDoc to return
        var mdoc: nullable MDoc = null is optional, writable

        # Same states than `CmdEntity::init_mentity`
        #
        # Plus returns `WarningNoMDoc` if no MDoc was found for the MEntity.
        redef fun init_command do
                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                if mdoc == null then
                        mdoc = if fallback then mentity.mdoc_or_fallback else mentity.mdoc
                end
                if mdoc == null then return new WarningNoMDoc(mentity)
                return res
        end

        # Render `mdoc` depending on `full_doc` and `format`
        fun render_comment: nullable Writable do
                var mdoc = self.mdoc
                if mdoc == null then return null

                if format == "html" then
                        if full_doc then return mdoc.html_documentation
                        return mdoc.html_synopsis
                end
                if full_doc then return mdoc.documentation
                return mdoc.synopsis
        end
end

# No MDoc for `mentity`
class WarningNoMDoc
        super CmdWarning

        # MEntity provided
        var mentity: MEntity

        redef fun to_s do return "No documentation for `{mentity.full_name}`."
end

# Get the link to a MEntity API documentation
class CmdEntityLink
        super CmdEntity

        # The link text to display
        var text: nullable String = null is optional, writable

        # The link title to display when the link is hovered
        var title: nullable String = null is optional, writable

        redef fun init_command do
                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                if text == null then
                        text = mentity.name
                end
                if title == null then
                        var mdoc = mentity.mdoc_or_fallback
                        if mdoc != null then
                                title = mdoc.synopsis
                        end
                end
                return res
        end
end

# An abstract inheritance command
#
# For things like ancestors, parents, children and descendants.
abstract class CmdInheritance
        super CmdEntityList

        autoinit(model, mainmodule, filter, mentity, mentity_name, limit, page, count, max)

        # Mainmodule for class linearization
        var mainmodule: MModule
end

# MEntity ancestors command
#
# Retrieve all the ancestors (direct and indirect) of a MEntity.
class CmdAncestors
        super CmdInheritance

        # Include direct parents in the ancestors list
        #
        # Default is `true`.
        var parents = true is optional, writable

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                var ancestors = mentity.collect_ancestors(mainmodule, filter).to_a
                if parents then
                        results = ancestors
                        return res
                end

                var parents = mentity.collect_parents(mainmodule, filter)
                var mentities = new HashSet[MEntity]
                for ancestor in ancestors do
                        if not parents.has(ancestor) then mentities.add ancestor
                end
                results = mentities.to_a
                return res
        end
end

# MEntity parents command
class CmdParents
        super CmdInheritance

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                results = mentity.collect_parents(mainmodule, filter).to_a
                return res
        end
end

# MEntity children command
class CmdChildren
        super CmdInheritance

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                results = mentity.collect_children(mainmodule, filter).to_a
                return res
        end
end

# MEntity descendants command
class CmdDescendants
        super CmdInheritance

        # Include direct children in the descendants list
        #
        # Default is `true`.
        var children = true is optional, writable

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                var descendants = mentity.collect_descendants(mainmodule, filter).to_a
                if children then
                        results = descendants
                        return res
                end

                var children = mentity.collect_children(mainmodule, filter)
                var mentities = new HashSet[MEntity]
                for descendant in descendants do
                        if not children.has(descendant) then mentities.add descendant
                end
                results = mentities.to_a
                return res
        end
end

# Linearization command
#
# Collects and linearizes definitions about an MEntity.
class CmdLinearization
        super CmdInheritance

        # Same states than `CmdEntity::init_mentity`
        #
        # Plus returns `WarningNoLinearization` if no linearization can be computed
        # from the mentity.
        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                sorter = null
                results = mentity.collect_linearization(mainmodule)
                if results == null then return new WarningNoLinearization(mentity)
                return res
        end
end

# No linearization computed for `mentity`.
class WarningNoLinearization
        super CmdWarning

        # MEntity provided
        var mentity: MEntity

        redef fun to_s do return "No linearization for `{mentity.full_name}`"
end

# A free text search command
class CmdSearch
        super CmdEntities

        # Free text command string
        var query: nullable String = null is optional, writable

        # Return states:
        # * `CmdSuccess`: everything was ok;
        # * `ErrorNoQuery`: no `query` provided.
        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res

                var query = self.query
                if query == null then return new ErrorNoQuery
                sorter = null
                results = model.find(query)
                return res
        end
end

# No query string given
class ErrorNoQuery
        super CmdError

        redef fun to_s do return "Missing search string"
end

# MEntity feature list
#
# Mostly a list of mentities defined in `mentity`.
class CmdFeatures
        super CmdEntityList

        # Same as `CmdEntity::init_mentity`
        #
        # Plus `WarningNoFeatures` if no features are found for `mentity`.
        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                var mentities = new Array[MEntity]
                if mentity isa MPackage then
                        mentities.add_all mentity.collect_mgroups(filter)
                        mentities.add_all mentity.collect_mmodules(filter)
                else if mentity isa MGroup then
                        mentities.add_all mentity.collect_mgroups(filter)
                        mentities.add_all mentity.collect_mmodules(filter)
                else if mentity isa MModule then
                        mentities.add_all mentity.collect_local_mclassdefs(filter)
                else if mentity isa MClass then
                        mentities.add_all mentity.collect_intro_mproperties(filter)
                        mentities.add_all mentity.collect_redef_mpropdefs(filter)
                else if mentity isa MClassDef then
                        mentities.add_all mentity.collect_intro_mpropdefs(filter)
                        mentities.add_all mentity.collect_redef_mpropdefs(filter)
                else if mentity isa MProperty then
                        mentities.add_all mentity.collect_mpropdefs(filter)
                else
                        return new WarningNoFeatures(mentity)
                end
                self.results = mentities
                return res
        end
end

# TODO remove once the filters/sorters are merged
class CmdIntros
        super CmdInheritance

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                if mentity isa MModule then
                        var mentities = mentity.collect_intro_mclasses(filter).to_a
                        self.results = mentities
                else if mentity isa MClass then
                        var mentities = mentity.collect_intro_mproperties(filter).to_a
                        self.results = mentities
                else if mentity isa MClassDef then
                        var mentities = mentity.collect_intro_mpropdefs(filter).to_a
                        mainmodule.linearize_mpropdefs(mentities)
                        self.results = mentities
                else
                        return new WarningNoFeatures(mentity)
                end
                return res
        end
end

# TODO remove once the filters/sorters are merged
class CmdRedefs
        super CmdInheritance

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                if mentity isa MModule then
                        var mentities = mentity.collect_redef_mclassdefs(filter).to_a
                        self.results = mentities
                else if mentity isa MClass then
                        var mentities = mentity.collect_redef_mpropdefs(filter).to_a
                        self.results = mentities
                else if mentity isa MClassDef then
                        var mentities = mentity.collect_redef_mpropdefs(filter).to_a
                        mainmodule.linearize_mpropdefs(mentities)
                        self.results = mentities
                else
                        return new WarningNoFeatures(mentity)
                end
                return res
        end
end

# TODO remove once the filters/sorters are merged
class CmdAllProps
        super CmdInheritance

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                if mentity isa MClass then
                        results = mentity.collect_accessible_mproperties(mainmodule, filter).to_a
                else
                        return new WarningNoFeatures(mentity)
                end
                return res
        end
end

# No feature list for `mentity`
class WarningNoFeatures
        super CmdWarning

        # MEntity provided
        var mentity: MEntity

        redef fun to_s do return "No features for `{mentity.full_name}`"
end

# Abstract command that returns source-code pieces
abstract class CmdCode
        super DocCommand

        autoinit(model, modelbuilder, filter, format)

        # ModelBuilder used to get AST nodes
        var modelbuilder: ModelBuilder

        # Rendering format
        #
        # Set the output format for this piece of code.
        # Can be "raw", "html" or "ansi".
        # Default is "raw".
        #
        # This format can be different than the format used in the command response.
        # For example you can choose to render code as HTML inside a JSON object response.
        # Another example is to render raw format to put into a HTML code tag.
        var format = "raw" is optional, writable

        # Render `node` depending on the selected `format`
        fun render_code(node: nullable ANode): nullable Writable do
                if node == null then return null
                if format == "html" then
                        var hl = new CmdHtmlightVisitor
                        hl.show_infobox = false
                        hl.highlight_node node
                        return hl.html
                else if format == "ansi" then
                        var hl = new AnsiHighlightVisitor
                        hl.highlight_node node
                        return hl.result
                end
                return node.location.text
        end
end

# Custom HtmlightVisitor for commands
#
# We create a new subclass so its behavior can be refined in clients without
# breaking the main implementation.
class CmdHtmlightVisitor
        super HtmlightVisitor
end

# Cmd that finds the source code related to an `mentity`
class CmdEntityCode
        super CmdEntity
        super CmdCode

        autoinit(model, modelbuilder, filter, mentity, mentity_name, format)

        # AST node to return
        var node: nullable ANode = null is optional, writable

        # Same as `CmdEntity::init_mentity`
        #
        # Plus `WarningNoCode` if no code/AST node is found for `mentity`.
        redef fun init_command do
                if node != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res
                var mentity = self.mentity.as(not null)

                if mentity isa MClass then mentity = mentity.intro
                if mentity isa MProperty then mentity = mentity.intro
                node = modelbuilder.mentity2node(mentity)
                if node == null then return new WarningNoCode(mentity)
                return res
        end
end

# No code for `mentity`
class WarningNoCode
        super CmdWarning

        # MEntity provided
        var mentity: MEntity

        redef fun to_s do return "No code for `{mentity.full_name}`"
end

# Model commands

# A command that returns a list of all mentities in a model
class CmdModelEntities
        super CmdEntities

        # Kind of mentities to be returned.
        #
        # Value must be one of "packages", "groups", "modules", "classes", "classdefs",
        # "properties", "propdefs" or "all".
        #
        # Default is "all".
        var kind = "all" is optional, writable

        # Default limit is `10`
        redef var limit = 10

        redef fun init_results do
                if results != null then return new CmdSuccess

                var res = super
                if not res isa CmdSuccess then return res

                var mentities = new Array[MEntity]
                if kind == "packages" then
                        mentities = model.collect_mpackages(filter).to_a
                else if kind == "groups" then
                        mentities = model.collect_mgroups(filter).to_a
                else if kind == "modules" then
                        mentities = model.collect_mmodules(filter).to_a
                else if kind == "classes" then
                        mentities = model.collect_mclasses(filter).to_a
                else if kind == "classdefs" then
                        mentities = model.collect_mclassdefs(filter).to_a
                else if kind == "properties" then
                        mentities = model.collect_mproperties(filter).to_a
                else if kind == "propdefs" then
                        mentities = model.collect_mpropdefs(filter).to_a
                else
                        mentities = model.collect_mentities(filter).to_a
                end
                results = mentities
                return res
        end
end

# A command that returns a random list of mentities from a model
class CmdRandomEntities
        super CmdModelEntities

        # Always return `CmdSuccess`
        redef fun init_results do
                if results != null then return new CmdSuccess
                var res = super
                if not res isa CmdSuccess then return res
                randomize
                return res
        end

        # Randomize mentities order
        fun randomize do
                var results = self.results
                if results == null then return
                results.shuffle
        end
end