module nitx
import model_utils
-import modelize_property
+import modelize
# Main class of the nit index tool
# NitIndex build the model using the toolcontext argument
# then wait for query on std in to display documentation
class NitIndex
private var toolcontext: ToolContext
- private var model: Model
- private var mbuilder: ModelBuilder
- private var mainmodule: MModule
- private var arguments: Array[String]
- private var renderer: PagerMatchesRenderer
+ private var model: Model is noinit
+ private var mbuilder: ModelBuilder is noinit
+ private var mainmodule: MModule is noinit
+ private var arguments: Array[String] is noinit
+ private var renderer: PagerMatchesRenderer is noinit
# New constructor to use the pre-calculated model when interpreting a module
init with_infos(mbuilder: ModelBuilder, mmodule: MModule) do
renderer = new PagerMatchesRenderer(self)
end
- init(toolcontext: ToolContext) do
+ init do
# We need a model to collect stufs
- self.toolcontext = toolcontext
self.arguments = toolcontext.option_context.rest
if arguments.length > 2 then
model = new Model
mbuilder = new ModelBuilder(model, toolcontext)
- # Here we load an process std modules
- #var dir = "NIT_DIR".environ
- #var mmodules = modelbuilder.parse_and_build(["{dir}/lib/standard/standard.nit"])
var mmodules = mbuilder.parse([arguments.first])
if mmodules.is_empty then return
mbuilder.run_phases
print "Loaded modules:"
var mmodules = new Array[MModule]
mmodules.add_all(model.mmodules)
- var sorter = new MModuleNameSorter
+ var sorter = new MEntityNameSorter
sorter.sort(mmodules)
for m in mmodules do
print "\t{m.name}"
fun prompt do
printn ">> "
- search(stdin.read_line)
+ search(sys.stdin.read_line)
end
fun search(entry: String) do
private class IndexQuery
var string: String
var keyword: String
- init(string: String, keyword: String) do
- self.string = string
- self.keyword = keyword
- end
end
private class IndexQueryPair
super IndexQuery
var category: String
- init(string: String, keyword: String, category: String) do
- super(string, keyword)
- self.category = category
- end
end
# A match to a query in the nit index
private class PagerMatchesRenderer
var index: NitIndex
- init(index: NitIndex) do self.index = index
fun render_matches(query: IndexQuery, matches: Collection[IndexMatch]) do
var pager = new Pager
pager.render
end
- private fun props_fulldoc(pager: Pager, raw_mprops: List[MProperty]) do
+ fun props_fulldoc(pager: Pager, raw_mprops: List[MProperty]) do
# group by module
var cats = new HashMap[MModule, Array[MProperty]]
for mprop in raw_mprops do
cats[key].add(mprop)
end
#sort groups
- var sorter = new MModuleNameSorter
+ var sorter = new MEntityNameSorter
var sorted = new Array[MModule]
sorted.add_all(cats.keys)
sorter.sort(sorted)
for mmodule in sorted do
var mprops = cats[mmodule]
pager.add("# matches in module {mmodule.namespace.bold}")
- var sorterp = new MPropertyNameSorter
- sorterp.sort(mprops)
+ sorter.sort(mprops)
for mprop in mprops do
end
fun add_indent do addn(" " * indent)
fun addn(text: String) do content.append(text.escape)
fun add_rule do add("\n---\n")
- fun render do sys.system("echo \"{content}\" | pager -r")
+ fun render do sys.system("echo \"{content}\" | less -r")
end
redef class MModule
pager.add(prototype)
pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
pager.indent = pager.indent + 1
- var sorter = new MModuleNameSorter
+ var sorter = new MEntityNameSorter
# imported modules
var imports = new Array[MModule]
for mmodule in in_importation.direct_greaters.to_a do
pager.indent = pager.indent - 1
end
# mclassdefs
- var csorter = new MClassDefNameSorter
var intros = new Array[MClassDef]
var redefs = new Array[MClassDef]
for mclassdef in mclassdefs do
end
# introductions
if not intros.is_empty then
- csorter.sort(intros)
+ sorter.sort(intros)
pager.add("")
pager.add("== introduced classes".bold)
pager.indent = pager.indent + 1
end
# refinements
if not redefs.is_empty then
- csorter.sort(redefs)
+ sorter.sort(redefs)
pager.add("")
pager.add("== refined classes".bold)
pager.indent = pager.indent + 1
var res = new FlatBuffer
if arity > 0 then
res.append("[")
- for i in [0..intro.parameter_names.length[ do
- res.append(intro.parameter_names[i])
- if i < intro.parameter_names.length - 1 then res.append(", ")
+ for i in [0..mparameters.length[ do
+ res.append(mparameters[i].name)
+ if i < mparameters.length - 1 then res.append(", ")
end
res.append("]")
end
redef fun content(index, pager) do
# intro comment
+ var sorter = new MEntityNameSorter
var mdoc = intro.mdoc
if mdoc != null then
for comment in mdoc.content do pager.add(comment.green)
# parents
var supers = self.in_hierarchy(index.mainmodule).direct_greaters.to_a
if not supers.is_empty then
- var csorter = new MClassNameSorter
- csorter.sort(supers)
+ sorter.sort(supers)
pager.add("")
pager.add("== supers".bold)
pager.indent = pager.indent + 1
pager.indent = pager.indent - 1
end
# intro mproperties
- var psorter = new MPropDefNameSorter
var mpropdefs = intro.mpropdefs
index.mainmodule.linearize_mpropdefs(mpropdefs)
for cat in intro.cats2mpropdefs.keys do
var defs = intro.cats2mpropdefs[cat].to_a
if defs.is_empty then continue
- psorter.sort(defs)
+ sorter.sort(defs)
pager.add("")
pager.add("== {cat}".bold)
pager.indent = pager.indent + 1
pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
pager.indent = pager.indent + 1
var mpropdefs = self.mpropdefs
- var psorter = new MPropDefNameSorter
+ var sorter = new MEntityNameSorter
index.mainmodule.linearize_mpropdefs(mpropdefs)
for cat in cats2mpropdefs.keys do
var defs = cats2mpropdefs[cat].to_a
- psorter.sort(defs)
+ sorter.sort(defs)
if defs.is_empty then continue
pager.add("")
pager.add("== {cat}".bold)
if not mproperty.is_init then res.append("fun ")
res.append(mproperty.to_console.bold)
if msignature != null then res.append(msignature.to_console)
- # FIXME: modifiers should be accessible via the model
- #if self isa ADeferredMethPropdef then ret = "{ret} is abstract"
- #if self isa AInternMethPropdef then ret = "{ret} is intern"
- #if self isa AExternMethPropdef then ret = "{ret} is extern"
+ if is_abstract then res.append " is abstract"
+ if is_intern then res.append " is intern"
+ if is_extern then res.append " is extern"
return res.to_s
end
end
end
redef class MParameterType
- redef fun to_console do return mclass.intro.parameter_names[rank]
+ redef fun to_console do return name
end
redef class MVirtualType
end
end
-redef class AAttrPropdef
- private fun read_accessor: String do
- var ret = "fun "
- #FIXME bug with standard::stream::FDStream::fd
- var name = mreadpropdef.mproperty.name
- if mpropdef.mproperty.visibility.to_s == "public" then ret = "{ret}{name.green}"
- if mpropdef.mproperty.visibility.to_s == "private" then ret = "{ret}{name.red}"
- if mpropdef.mproperty.visibility.to_s == "protected" then ret = "{ret}{name.yellow}"
- ret = "{ret}: {n_type.to_s}"
- if n_kwredef != null then ret = "redef {ret}"
- return ret
- end
-
- private fun write_accessor: String do
- var ret = "fun "
- var name = "{mreadpropdef.mproperty.name}="
- if n_readable != null and n_readable.n_visibility != null then
- if n_readable.n_visibility isa APublicVisibility then ret = "{ret}{name.green}"
- if n_readable.n_visibility isa APrivateVisibility then ret = "{ret}{name.red}"
- if n_readable.n_visibility isa AProtectedVisibility then ret = "{ret}{name.yellow}"
- else
- ret = "{ret}{name.red}"
- end
- ret = "{ret}({mreadpropdef.mproperty.name}: {n_type.to_s})"
- if n_kwredef != null then ret = "redef {ret}"
- return ret
- end
-end
-
# Redef String class to add a function to color the string
redef class String
nitlanguage / nit.git / blobdiff