X-Git-Url: http://nitlanguage.org diff --git a/src/loader.nit b/src/loader.nit index 90c439f..eb3d06d 100644 --- a/src/loader.nit +++ b/src/loader.nit @@ -287,6 +287,20 @@ redef class ModelBuilder 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] @@ -353,6 +367,13 @@ redef class ModelBuilder 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) @@ -395,12 +416,8 @@ redef class ModelBuilder return null 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` + # 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 # Check `project.ini` that indicate a project var ini = null @@ -410,32 +427,40 @@ redef class ModelBuilder ini = new ConfigTree(inipath) end - # 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 + 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 and ini.has_key("name") then pn = ini["name"] + 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 @@ -450,8 +475,6 @@ redef class ModelBuilder # 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 @@ -459,8 +482,7 @@ redef class ModelBuilder end mgroup.filepath = dirpath - mgroups[module_absolute_path(dirpath)] = mgroup - mgroups[module_absolute_path(dirpath2)] = mgroup + mgroups[rdp] = mgroup return mgroup end @@ -693,14 +715,77 @@ redef class ModelBuilder # 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 @@ -755,7 +840,7 @@ redef class ModelBuilder 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 @@ -814,9 +899,9 @@ redef class ModelBuilder 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