module loader
import modelbuilder_base
+import ini
redef class ToolContext
# Option --path
return res.first
end
+ # Search groups named `name` from paths `lookpaths`.
+ private fun search_group_in_paths(name: String, lookpaths: Collection[String]): ArraySet[MGroup]
+ do
+ var res = new ArraySet[MGroup]
+ for dirname in lookpaths do
+ # try a single group directory
+ var mg = get_mgroup(dirname/name)
+ if mg != null then
+ res.add mg
+ end
+ end
+ return res
+ end
+
# Cache for `identify_file` by realpath
private var identified_files_by_path = new HashMap[String, nullable ModulePath]
mgroup.filepath = path
mproject.root = mgroup
toolcontext.info("found singleton project `{pn}` at {path}", 2)
+
+ # Attach homonymous `ini` file to the project
+ var inipath = path.dirname / "{pn}.ini"
+ if inipath.file_exists then
+ var ini = new ConfigTree(inipath)
+ mproject.ini = ini
+ end
end
var res = new ModulePath(pn, path, mgroup)
return mgroups[rdp]
end
- # Hack, a group is determined by one of the following:
- # * the presence of a honomymous nit file
- # * the fact that the directory is named `src`
- # * the fact that there is a sub-directory named `src`
+ # Filter out non-directories
+ var stat = dirpath.file_stat
+ if stat == null or not stat.is_dir then
+ mgroups[rdp] = null
+ return null
+ end
+
+ # By default, the name of the project or group is the base_name of the directory
var pn = rdp.basename(".nit")
- var mp = dirpath.join_path(pn + ".nit").simplify_path
-
- # dirpath2 is the root directory
- # dirpath is the src subdirectory directory, if any, else it is the same that dirpath2
- var dirpath2 = dirpath
- if not mp.file_exists then
- if pn == "src" then
- # With a src directory, the group name is the name of the parent directory
- dirpath2 = rdp.dirname
- pn = dirpath2.basename
- else
- # Check a `src` subdirectory
- dirpath = dirpath2 / "src"
- if not dirpath.file_exists then
- # All rules failed, so return null
+
+ # Check `project.ini` that indicate a project
+ var ini = null
+ var parent = null
+ var inipath = dirpath / "project.ini"
+ if inipath.file_exists then
+ ini = new ConfigTree(inipath)
+ end
+
+ if ini == null then
+ # No ini, multiple course of action
+
+ # The root of the directory hierarchy in the file system.
+ if rdp == "/" then
+ mgroups[rdp] = null
+ return null
+ end
+
+ # Special stopper `projects.ini`
+ if (dirpath/"projects.ini").file_exists then
+ # dirpath cannot be a project since it is a project directory
+ mgroups[rdp] = null
+ return null
+ end
+
+ # check the parent directory (if it does not contain the stopper file)
+ var parentpath = dirpath.join_path("..").simplify_path
+ var stopper = parentpath / "projects.ini"
+ if not stopper.file_exists then
+ # Recursively get the parent group
+ parent = get_mgroup(parentpath)
+ if parent == null then
+ # Parent is not a group, thus we are not a group either
+ mgroups[rdp] = null
return null
end
end
end
- # check parent directory
- var parentpath = dirpath2.join_path("..").simplify_path
- var parent = get_mgroup(parentpath)
-
var mgroup
if parent == null then
# no parent, thus new project
+ if ini != null then pn = ini["project.name"] or else pn
var mproject = new MProject(pn, model)
mgroup = new MGroup(pn, mproject, null) # same name for the root group
mproject.root = mgroup
toolcontext.info("found project `{mproject}` at {dirpath}", 2)
+ mproject.ini = ini
else
mgroup = new MGroup(pn, parent.mproject, parent)
toolcontext.info("found sub group `{mgroup.full_name}` at {dirpath}", 2)
# in src first so the documentation of the project code can be distinct for the documentation of the project usage
var readme = dirpath.join_path("README.md")
if not readme.file_exists then readme = dirpath.join_path("README")
- if not readme.file_exists then readme = dirpath2.join_path("README.md")
- if not readme.file_exists then readme = dirpath2.join_path("README")
if readme.file_exists then
var mdoc = load_markdown(readme)
mgroup.mdoc = mdoc
end
mgroup.filepath = dirpath
- mgroups[module_absolute_path(dirpath)] = mgroup
- mgroups[module_absolute_path(dirpath2)] = mgroup
+ mgroups[rdp] = mgroup
return mgroup
end
# This method handles qualified names as used in `AModuleName`.
fun seach_module_by_amodule_name(n_name: AModuleName, mgroup: nullable MGroup): nullable ModulePath
do
- if n_name.n_quad != null then mgroup = null # Start from top level
- for grp in n_name.n_path do
- var path = search_mmodule_by_name(grp, mgroup, grp.text)
- if path == null then return null # Forward error
- mgroup = path.mgroup
- end
var mod_name = n_name.n_id.text
- return search_mmodule_by_name(n_name, mgroup, mod_name)
+
+ # If a quad is given, we ignore the starting group (go from path)
+ if n_name.n_quad != null then mgroup = null
+
+ # If name not qualified, just search the name
+ if n_name.n_path.is_empty then
+ # Fast search if no n_path
+ return search_mmodule_by_name(n_name, mgroup, mod_name)
+ end
+
+ # If qualified and in a group
+ if mgroup != null then
+ # First search in the project
+ var r = mgroup.mproject.root
+ assert r != null
+ scan_group(r)
+ # Get all modules with the final name
+ var res = r.mmodule_paths_by_name(mod_name)
+ # Filter out the name that does not match the qualifiers
+ res = [for x in res do if match_amodulename(n_name, x) then x]
+ if res.not_empty then
+ if res.length > 1 then
+ error(n_name, "Error: conflicting module files for `{mod_name}`: `{res.join(",")}`")
+ end
+ return res.first
+ end
+ end
+
+ # If no module yet, then assume that the first element of the path
+ # Is to be searched in the path.
+ var root_name = n_name.n_path.first.text
+ var roots = search_group_in_paths(root_name, paths)
+ if roots.is_empty then
+ error(n_name, "Error: cannot find `{root_name}`. Tried: {paths.join(", ")}.")
+ return null
+ end
+
+ var res = new ArraySet[ModulePath]
+ for r in roots do
+ # Then, for each root, collect modules that matches the qualifiers
+ scan_group(r)
+ var root_res = r.mmodule_paths_by_name(mod_name)
+ for x in root_res do if match_amodulename(n_name, x) then res.add x
+ end
+ if res.not_empty then
+ if res.length > 1 then
+ error(n_name, "Error: conflicting module files for `{mod_name}`: `{res.join(",")}`")
+ end
+ return res.first
+ end
+ # If still nothing, just call a basic search that will fail and will produce an error message
+ error(n_name, "Error: cannot find module `{mod_name}` from `{root_name}`. Tried: {paths.join(", ")}.")
+ return null
+ end
+
+ # Is elements of `n_name` correspond to the group nesting of `m`?
+ #
+ # Basically it check that `bar::foo` matches `bar/foo.nit` and `bar/baz/foo.nit`
+ # but not `baz/foo.nit` nor `foo/bar.nit`
+ #
+ # Is used by `seach_module_by_amodule_name` to validate qualified names.
+ private fun match_amodulename(n_name: AModuleName, m: ModulePath): Bool
+ do
+ var g: nullable MGroup = m.mgroup
+ for grp in n_name.n_path.reverse_iterator do
+ while g != null and grp.text != g.name do
+ g = g.parent
+ end
+ end
+ return g != null
end
# Analyze the module importation and fill the module_importation_hierarchy
mmodule.set_visibility_for(sup, mvisibility)
end
if stdimport then
- var mod_name = "standard"
+ var mod_name = "core"
var sup = self.get_mmodule_by_name(nmodule, null, mod_name)
if sup == null then
nmodule.mmodule = null # invalidate the module
self.toolcontext.info("{mmodule} imports {mmodule.in_importation.direct_greaters.join(", ")}", 3)
- # Force standard to be public if imported
+ # Force `core` to be public if imported
for sup in mmodule.in_importation.greaters do
- if sup.name == "standard" then
+ if sup.name == "core" then
mmodule.set_visibility_for(sup, public_visibility)
end
end
redef fun to_s do return filepath
end
+redef class MProject
+ # The associated `.ini` file, if any
+ #
+ # The `ini` file is given as is and might contain invalid or missing information.
+ #
+ # Some projects, like stand-alone projects or virtual projects have no `ini` file associated.
+ var ini: nullable ConfigTree = null
+end
+
redef class MGroup
# Modules paths associated with the group
var module_paths = new Array[ModulePath]