The container class of a Nit object-oriented model.

# The container class of a Nit object-oriented model.
# A model knows modules, classes and properties and can retrieve them.
class Model
	super MEntity

	redef fun model do return self

	# Place-holder object that means no-location
	#
	# See `MEntity::location`
	var no_location = new Location(null, 0, 0, 0, 0)
end

src/model/model_base.nit:21,1--32,3

nitc :: mpackage $ Model

redef class Model

	# Full package importation graph
	# Each package is in relation with itself
	var mpackage_importation_graph = new HashDigraph[MPackage]

	# packages of the model
	var mpackages = new Array[MPackage]

	# Collections of package grouped by their names
	private var mpackage_by_name = new MultiHashMap[String, MPackage]

	# Return all package named `name`
	# If such a package is not yet loaded, null is returned (instead of an empty array)
	fun get_mpackages_by_name(name: String): nullable Array[MPackage]
	do
		if mpackage_by_name.has_key(name) then
			return mpackage_by_name[name]
		else
			return null
		end
	end
end

src/model/mpackage.nit:182,1--204,3

nitc :: mmodule $ Model

# The container class of a Nit object-oriented model.
#
# A model knows modules, classes and properties and can retrieve them.
#
# However, a model is not a program or a library as it can contains modules
# found by the system (including broken ones) but not used.
redef class Model
	# All known modules
	var mmodules = new Array[MModule]

	# Full module importation hierarchy including private or nested links.
	var mmodule_importation_hierarchy = new POSet[MModule]

	# Collections of modules grouped by their short names
	private var mmodules_by_name = new MultiHashMap[String, MModule]

	# Return all module named `name`
	# If such a module does not exist, null is returned (instead of an empty array)
	#
	# Visibility or modules are not considered
	fun get_mmodules_by_name(name: String): nullable Array[MModule]
	do
		if mmodules_by_name.has_key(name) then
			return mmodules_by_name[name]
		else
			return null
		end
	end
end

src/model/mmodule.nit:23,1--51,3

nitc :: model $ Model

redef class Model
	# All known classes
	var mclasses = new Array[MClass]

	# All known properties
	var mproperties = new Array[MProperty]

	# Hierarchy of class definition.
	#
	# Each classdef is associated with its super-classdefs in regard to
	# its module of definition.
	#
	# ~~~
	# var m = new ModelDiamond
	# assert     m.mclassdef_hierarchy.has_edge(m.mclassdef_b, m.mclassdef_a)
	# assert not m.mclassdef_hierarchy.has_edge(m.mclassdef_a, m.mclassdef_b)
	# assert not m.mclassdef_hierarchy.has_edge(m.mclassdef_b, m.mclassdef_c)
	# ~~~
	var mclassdef_hierarchy = new POSet[MClassDef]

	# Class-type hierarchy restricted to the introduction.
	#
	# The idea is that what is true on introduction is always true whatever
	# the module considered.
	# Therefore, this hierarchy is used for a fast positive subtype check.
	#
	# This poset will evolve in a monotonous way:
	# * Two non connected nodes will remain unconnected
	# * New nodes can appear with new edges
	private var intro_mtype_specialization_hierarchy = new POSet[MClassType]

	# Global overlapped class-type hierarchy.
	# The hierarchy when all modules are combined.
	# Therefore, this hierarchy is used for a fast negative subtype check.
	#
	# This poset will evolve in an anarchic way. Loops can even be created.
	#
	# FIXME decide what to do on loops
	private var full_mtype_specialization_hierarchy = new POSet[MClassType]

	# Collections of classes grouped by their short name
	private var mclasses_by_name = new MultiHashMap[String, MClass]

	# Return all classes named `name`.
	#
	# If such a class does not exist, null is returned
	# (instead of an empty array)
	#
	# Visibility or modules are not considered
	#
	# ~~~
	# var m = new ModelStandalone
	# assert m.get_mclasses_by_name("Object") == [m.mclass_o]
	# assert m.get_mclasses_by_name("Fail") == null
	# ~~~
	fun get_mclasses_by_name(name: String): nullable Array[MClass]
	do
		return mclasses_by_name.get_or_null(name)
	end

	# Collections of properties grouped by their short name
	private var mproperties_by_name = new MultiHashMap[String, MProperty]

	# Return all properties named `name`.
	#
	# If such a property does not exist, null is returned
	# (instead of an empty array)
	#
	# Visibility or modules are not considered
	fun get_mproperties_by_name(name: String): nullable Array[MProperty]
	do
		return mproperties_by_name.get_or_null(name)
	end

	# The only null type
	var null_type = new MNullType(self)

	# The only bottom type
	var bottom_type: MBottomType = null_type.as_notnull

	# Build an ordered tree with from `concerns`
	fun concerns_tree(mconcerns: Collection[MConcern]): ConcernsTree do
		var seen = new HashSet[MConcern]
		var res = new ConcernsTree

		var todo = new Array[MConcern]
		todo.add_all mconcerns

		while not todo.is_empty do
			var c = todo.pop
			if seen.has(c) then continue
			var pc = c.parent_concern
			if pc == null then
				res.add(null, c)
			else
				res.add(pc, c)
				todo.add(pc)
			end
			seen.add(c)
		end

		return res
	end
end

src/model/model.nit:42,1--145,3

nitc :: model_viz $ Model

redef class Model
	# Generate a MPackageTree based on the packages, groups and modules known in the model
	fun to_mpackage_tree: MPackageTree
	do
		var res = new MPackageTree(self)
		for p in mpackages do
			for g in p.mgroups do
				res.add(g.parent, g)
				for m in g.mmodules do
					res.add(g, m)
				end
			end
		end
		return res
	end
end

src/model/model_viz.nit:115,1--130,3

nitc :: model_collect $ Model

redef class Model

	# Collect all MPackages in `self`
	fun collect_mpackages(filter: nullable ModelFilter): HashSet[MPackage] do
		var res = new HashSet[MPackage]
		for mpackage in mpackages do
			if filter == null or filter.accept_mentity(mpackage) then res.add(mpackage)
		end
		return res
	end

	# Collect all MGroups in `self`
	fun collect_mgroups(filter: nullable ModelFilter): HashSet[MGroup] do
		var res = new HashSet[MGroup]
		for mpackage in collect_mpackages(filter) do
			res.add_all mpackage.collect_all_mgroups(filter)
		end
		return res
	end

	# Collect all MModules in `self`
	fun collect_mmodules(filter: nullable ModelFilter): HashSet[MModule] do
		var res = new HashSet[MModule]
		for mpackage in collect_mpackages(filter) do
			res.add_all mpackage.collect_all_mmodules(filter)
		end
		return res
	end

	# Collect all MClasses in `self`
	fun collect_mclasses(filter: nullable ModelFilter): HashSet[MClass] do
		var res = new HashSet[MClass]
		for mclass in mclasses do
			if filter == null or filter.accept_mentity(mclass) then res.add mclass
		end
		return res
	end

	# Collect all MClasses introduced in `self`
	fun collect_intro_mclasses(filter: nullable ModelFilter): HashSet[MClass] do
		var res = new HashSet[MClass]
		for mpackage in collect_mpackages(filter) do
			res.add_all mpackage.collect_intro_mclasses(filter)
		end
		return res
	end

	# Collect all MClassDefs in `self`
	fun collect_mclassdefs(filter: nullable ModelFilter): HashSet[MClassDef] do
		var res = new HashSet[MClassDef]
		for mclass in collect_mclasses(filter) do
			res.add_all mclass.collect_mclassdefs(filter)
		end
		return res
	end

	# Collect all MProperties introduced in `self`
	fun collect_intro_mproperties(filter: nullable ModelFilter): HashSet[MProperty] do
		var res = new HashSet[MProperty]
		for mpackage in collect_mpackages(filter) do
			res.add_all mpackage.collect_intro_mproperties(filter)
		end
		return res
	end

	# Collect all MProperties in `self`
	fun collect_mproperties(filter: nullable ModelFilter): HashSet[MProperty] do
		var res = new HashSet[MProperty]
		for mproperty in mproperties do
			if filter == null or filter.accept_mentity(mproperty) then res.add mproperty
		end
		return res
	end

	# Collect all MPropDefs in `self`
	fun collect_mpropdefs(filter: nullable ModelFilter): HashSet[MPropDef] do
		var res = new HashSet[MPropDef]
		for mproperty in collect_mproperties(filter) do
			for mpropdef in mproperty.mpropdefs do
				if filter == null or filter.accept_mentity(mpropdef) then res.add mpropdef
			end
		end
		return res
	end

	# Collect all MEntities in `self`
	fun collect_mentities(filter: nullable ModelFilter): HashSet[MEntity] do
		var res = new HashSet[MEntity]
		res.add_all collect_mpackages(filter)
		res.add_all collect_mgroups(filter)
		res.add_all collect_mmodules(filter)
		res.add_all collect_mclasses(filter)
		res.add_all collect_mclassdefs(filter)
		res.add_all collect_mproperties(filter)
		res.add_all collect_mpropdefs(filter)
		return res
	end

	# Searches the MEntity that matches `full_name`.
	fun mentity_by_full_name(full_name: String, filter: nullable ModelFilter): nullable MEntity do
		for mentity in collect_mentities(filter) do
			if filter != null and not filter.accept_mentity(mentity) then continue
			if mentity.full_name == full_name then return mentity
		end
		return null
	end

	# Searches the MEntities that matches `full_name`.
	fun mentities_by_name(name: String, filter: nullable ModelFilter): Array[MEntity] do
		var res = new Array[MEntity]
		for mentity in collect_mentities(filter) do
			if filter != null and not filter.accept_mentity(mentity) then continue
			if mentity.name == name then res.add mentity
		end
		return res
	end
end

src/model/model_collect.nit:148,1--264,3

nitc :: model_visitor $ Model

redef class Model
	# Visit all the packages of the model.
	redef fun visit_all(v) do
		for x in mpackages do v.enter_visit(x)
	end
end

src/model/model_visitor.nit:106,1--111,3

nitc :: model_index $ Model

redef class Model

	# Keep a direct link to mentities by full name to speed up `mentity_from_uri`
	var mentities_by_full_name: HashMap[String, MEntity] is lazy do
		var mentities_by_full_name = new HashMap[String, MEntity]
		for mentity in collect_mentities do
			mentities_by_full_name[mentity.full_name] = mentity
		end
		return mentities_by_full_name
	end

	# ModelIndex used to perform searches
	var index: ModelIndex is lazy, writable do
		var index = new ModelIndex
		for mentity in collect_mentities do
			if mentity isa MClassDef or mentity isa MPropDef then continue
			index.index mentity
		end
		return index
	end

	redef fun mentities_by_name(name, filter) do
		var res = new Array[MEntity]
		if not index.names.has_key(name) then return res
		for mentity in index.names[name] do
			if filter == null or filter.accept_mentity(mentity) then res.add mentity
		end
		return res
	end

	redef fun mentity_by_full_name(full_name, filter) do
		if mentities_by_full_name.has_key(full_name) then
			var mentity = mentities_by_full_name[full_name]
			if filter == null or filter.accept_mentity(mentity) then return mentity
		end
		return null
	end

	private var score_sorter = new ScoreComparator
	private var vis_sorter = new VisibilityComparator
	private var kind_sorter = new MEntityComparator
	private var name_sorter = new NameComparator
	private var lname_sorter = new NameLengthComparator
	private var fname_sorter = new FullNameComparator
	private var lfname_sorter = new FullNameLengthComparator

	# Search mentities based on a `query` string
	#
	# Lookup the index for anything matching `query` and return `limit` results.
	#
	# The algorithm used is the following:
	# 1- lookup by name prefix
	# 2- lookup by full_name prefix
	# 3- loopup by levenshtein distance
	#
	# At each step if the `limit` is reached, the algorithm stops and returns the results.
	fun find(query: String, limit: nullable Int, filter: nullable ModelFilter): Array[MEntity] do
		# Find, lookup by name prefix
		var matches = index.find_by_name_prefix(query, filter).uniq.
			sort(lname_sorter, name_sorter, kind_sorter)
		if limit != null and matches.length >= limit then
			return matches.limit(limit).rerank.sort(vis_sorter, score_sorter).mentities
		end
		matches = matches.rerank.sort(vis_sorter, score_sorter)

		# If limit not reached, lookup by full_name prefix
		var malus = matches.length
		var full_matches = new IndexMatches
		for match in index.find_by_full_name_prefix(query, filter).
			sort(kind_sorter, lfname_sorter, fname_sorter) do
			match.score += malus
			full_matches.add match
		end
		matches = matches.uniq
		if limit != null and matches.length + full_matches.length >= limit then
			matches.add_all full_matches
			matches = matches.uniq.limit(limit).rerank.sort(vis_sorter, score_sorter)
			return matches.mentities
		end

		# If limit not reached, lookup by similarity
		malus = matches.length
		var sim_matches = new IndexMatches
		for match in index.find_by_similarity(query, filter).sort(score_sorter, kind_sorter, lname_sorter, name_sorter) do
			match.score += malus
			sim_matches.add match
		end
		matches.add_all sim_matches
		matches = matches.uniq
		if limit != null then matches = matches.limit(limit)
		return matches.rerank.sort(vis_sorter, score_sorter).mentities
	end
end

src/model/model_index.nit:133,1--225,3

nitc :: codesmells_metrics $ Model

redef class Model
	fun get_avg_parameter: Float do
		var counter = new Counter[MMethodDef]
		var filter = new ModelFilter
		for mclassdef in collect_mclassdefs(filter) do
			for method in mclassdef.collect_intro_and_redef_mpropdefs(filter) do
			# check if the property is a method definition
				if not method isa MMethodDef then continue
				#Check if method has a signature
				if method.msignature == null then continue
				if method.msignature.mparameters.length == 0 then continue
				counter[method] = method.msignature.mparameters.length
			end
		end
		return counter.avg + counter.std_dev
	end

	fun get_avg_attribut: Float do
		var counter = new Counter[MClassDef]
		var filter = new ModelFilter
		for mclassdef in collect_mclassdefs(filter) do
			var number_attributs = mclassdef.collect_intro_and_redef_mattributes(filter).length
			if number_attributs != 0 then counter[mclassdef] = number_attributs
		end
		return counter.avg + counter.std_dev
	end

	fun get_avg_method: Float do
		var counter = new Counter[MClassDef]
		var filter = new ModelFilter
		for mclassdef in collect_mclassdefs(filter) do
			var number_methodes = mclassdef.collect_intro_and_redef_methods(filter).length
			if number_methodes != 0 then counter[mclassdef] = number_methodes
		end
		return counter.avg + counter.std_dev
	end

	fun get_avg_linenumber(model_builder: ModelBuilder): Float do
		var methods_analyse_metrics = new Counter[MClassDef]
		var filter = new ModelFilter
		for mclassdef in collect_mclassdefs(filter) do
			var result = 0
			var count = 0
			for mmethoddef in call_analyze_methods(mclassdef,model_builder, filter) do
				result += mmethoddef.line_number
				if mmethoddef.line_number == 0 then continue
				count += 1
			end
			if not mclassdef.collect_local_mproperties(filter).length != 0 then continue
			if count == 0 then continue
			methods_analyse_metrics[mclassdef] = (result/count).to_i
		end
		return methods_analyse_metrics.avg + methods_analyse_metrics.std_dev
	end
end

src/metrics/codesmells_metrics.nit:376,1--430,3

nitc :: html_model $ Model

redef class Model
	# Get a markdown processor for Nitdoc comments.
	var nitdoc_md_processor: MarkdownProcessor is lazy, writable do
		var proc = new MarkdownProcessor
		proc.decorator = new NitdocDecorator
		return proc
	end

	# Get a markdown inline processor for Nitdoc comments.
	#
	# This processor is specificaly designed to inlinable doc elements like synopsis.
	var nitdoc_inline_processor: MarkdownProcessor is lazy, writable do
		var proc = new MarkdownProcessor
		proc.decorator = new InlineDecorator
		return proc
	end
end

src/doc/templates/html_model.nit:554,1--570,3

class Model

Summary

The container class of a Nit object-oriented model.

Introduced properties

_bottom_type

_fname_sorter

_full_mtype_specialization_hierarchy

_index

_intro_mtype_specialization_hierarchy

_kind_sorter

_lfname_sorter

_lname_sorter

_mclassdef_hierarchy

_mclasses

_mclasses_by_name

_mentities_by_full_name

_mmodule_importation_hierarchy

_mmodules

_mmodules_by_name

_mpackage_by_name

_mpackage_importation_graph

_mpackages

_mproperties

_mproperties_by_name

_name_sorter

_nitdoc_inline_processor

_nitdoc_md_processor

_no_location

_null_type

_score_sorter

_vis_sorter

bottom_type

bottom_type=

collect_intro_mclasses

collect_intro_mproperties

collect_mclassdefs

collect_mclasses

collect_mentities

collect_mgroups

collect_mmodules

collect_mpackages

collect_mpropdefs

collect_mproperties

concerns_tree

defaultinit

find

fname_sorter

fname_sorter=

full_mtype_specialization_hierarchy

full_mtype_specialization_hierarchy=

get_avg_attribut

get_avg_linenumber

get_avg_method

get_avg_parameter

get_mclasses_by_name

get_mmodules_by_name

get_mpackages_by_name

get_mproperties_by_name

index

index=

intro_mtype_specialization_hierarchy

intro_mtype_specialization_hierarchy=

kind_sorter

kind_sorter=

lfname_sorter

lfname_sorter=

lname_sorter

lname_sorter=

mclassdef_hierarchy

mclassdef_hierarchy=

mclasses

mclasses=

mclasses_by_name

mclasses_by_name=

mentities_by_full_name

mentities_by_full_name=

mentities_by_name

mentity_by_full_name

mmodule_importation_hierarchy

mmodule_importation_hierarchy=