eric/ConfigKit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Select shallow directory import sources

Browse Source
This commit is contained in:
Eric Rakestraw
2026-10-19 20:13:33 +00:00
parent a0d13962bd
commit 55a59de6db
3 changed files with 381 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
internal/engine/import_selection.go
View File

@@ -41,8 +41,8 @@ func selectNamedImportCandidates(access *filesystemAccess, basePath string, spec
}
seen[candidatePath] = struct{}{}
var site importFieldSite
if index < len(spec.pathSites) {
site = spec.pathSites[index]
if index < len(spec.selectorSites) {
site = spec.selectorSites[index]
} else {
site = spec.fieldSites["path"]
}
@@ -53,7 +53,7 @@ func selectNamedImportCandidates(access *filesystemAccess, basePath string, spec
})
candidates := make([]selectedImportCandidate, 0, len(normalized))
for _, candidate := range normalized {
missing, diagnostic := validateNamedImportTarget(access, candidate, policy.required)
missing, _, diagnostic := validateNamedImportTarget(access, candidate, policy.required, false)
if diagnostic != nil {
return importSelection{}, []Diagnostic{*diagnostic}
}
@@ -72,43 +72,159 @@ func selectNamedImportCandidates(access *filesystemAccess, basePath string, spec
return selection, nil
}
func validateNamedImportTarget(access *filesystemAccess, candidate selectedImportCandidate, required bool) (bool, *Diagnostic) {
func selectShallowDirectoryImportCandidates(access *filesystemAccess, basePath string, spec importDeclarationSpec, policy resolvedImportPolicy, limits importLimits, accounting *importAccounting) (importSelection, []Diagnostic) {
roots := make([]selectedImportCandidate, 0, len(spec.paths))
seenRoots := make(map[string]struct{}, len(spec.paths))
for index, relative := range spec.paths {
accessPath := access.join(basePath, relative)
candidatePath := normalizedImportCandidatePath(access, accessPath)
if _, exists := seenRoots[candidatePath]; exists {
continue
}
seenRoots[candidatePath] = struct{}{}
site := spec.fieldSites["dir"]
if index < len(spec.selectorSites) {
site = spec.selectorSites[index]
}
roots = append(roots, selectedImportCandidate{path: candidatePath, accessPath: accessPath, site: site})
}
sort.Slice(roots, func(left, right int) bool { return roots[left].path < roots[right].path })
if accounting == nil {
accounting = &importAccounting{}
}
discovered := make([]selectedImportCandidate, 0)
seenCandidates := make(map[string]struct{})
for _, root := range roots {
missing, isDirectory, diagnostic := validateNamedImportTarget(access, root, false, true)
if diagnostic != nil {
return importSelection{}, []Diagnostic{*diagnostic}
}
if missing {
continue
}
if !isDirectory {
return importSelection{}, []Diagnostic{*importSelectionDiagnostic(root.site, CodeImportInvalid, "directory search root is not a directory")}
}
entries := make([]fs.DirEntry, 0)
var problem *Diagnostic
err := access.readDirectory(root.accessPath, func(entry fs.DirEntry) bool {
accounting.entries++
if accounting.entries > limits.entries {
problem = importSelectionDiagnostic(root.site, CodeImportLimitExceeded, "directory search exceeds the directory-entry visit limit")
return false
}
entries = append(entries, entry)
return true
})
if problem != nil {
return importSelection{}, []Diagnostic{*problem}
}
if errors.Is(err, fs.ErrNotExist) {
continue
}
if err != nil {
return importSelection{}, []Diagnostic{*importSelectionDiagnostic(root.site, CodeImportInvalid, "directory search root could not be read")}
}
sort.Slice(entries, func(left, right int) bool { return entries[left].Name() < entries[right].Name() })
for _, entry := range entries {
if entry.IsDir() || !matchesImportFilename(entry.Name(), policy.pattern) {
continue
}
accessPath := access.join(root.accessPath, entry.Name())
candidate := selectedImportCandidate{
path: normalizedImportCandidatePath(access, accessPath), accessPath: accessPath, site: root.site,
}
if _, exists := seenCandidates[candidate.path]; exists {
continue
}
seenCandidates[candidate.path] = struct{}{}
discovered = append(discovered, candidate)
}
}
sort.Slice(discovered, func(left, right int) bool { return discovered[left].path < discovered[right].path })
selected := make([]selectedImportCandidate, 0, len(discovered))
for _, candidate := range discovered {
missing, isDirectory, diagnostic := validateNamedImportTarget(access, candidate, false, true)
if diagnostic != nil {
return importSelection{}, []Diagnostic{*diagnostic}
}
if missing || isDirectory || excludedBasename(path.Base(candidate.path), policy.exclude) {
continue
}
selected = append(selected, candidate)
}
if policy.required && len(selected) == 0 {
return importSelection{}, []Diagnostic{*importSelectionDiagnostic(spec.fieldSites["dir"], CodeImportMissing, "required directory import selected no files")}
}
selection := importSelection{candidates: selected}
if len(selected) != 0 {
selection.outcome = importSelectionHasCandidates
}
return selection, nil
}
func normalizedImportCandidatePath(access *filesystemAccess, accessPath string) string {
if access.native != nil {
return accessPath
}
return filepath.ToSlash(filepath.Clean(accessPath))
}
func matchesImportFilename(name string, patterns []string) bool {
if patterns == nil {
return true
}
for _, pattern := range patterns {
matched, err := path.Match(pattern, name)
if err == nil && matched {
return true
}
}
return false
}
func validateNamedImportTarget(access *filesystemAccess, candidate selectedImportCandidate, required, allowDirectory bool) (bool, bool, *Diagnostic) {
if !access.contains(candidate.accessPath) {
return false, importSelectionDiagnostic(candidate.site, CodeImportOutsideRoot, "import target is outside the configuration root")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportOutsideRoot, "import target is outside the configuration root")
}
canonical, err := access.canonical(candidate.accessPath)
if err != nil {
if errors.Is(err, fs.ErrNotExist) {
if required {
return false, importSelectionDiagnostic(candidate.site, CodeImportMissing, "required import target does not exist")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportMissing, "required import target does not exist")
}
return true, nil
return true, false, nil
}
if errors.Is(err, fs.ErrPermission) {
return false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target cannot be accessed")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target cannot be accessed")
}
return false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target could not be canonicalized")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target could not be canonicalized")
}
if !access.contains(canonical) {
return false, importSelectionDiagnostic(candidate.site, CodeImportOutsideRoot, "import target resolves outside the configuration root")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportOutsideRoot, "import target resolves outside the configuration root")
}
info, err := access.stat(canonical)
if err != nil {
if errors.Is(err, fs.ErrNotExist) {
if required {
return false, importSelectionDiagnostic(candidate.site, CodeImportMissing, "required import target does not exist")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportMissing, "required import target does not exist")
}
return true, nil
return true, false, nil
}
if errors.Is(err, fs.ErrPermission) {
return false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target cannot be accessed")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target cannot be accessed")
}
return false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target could not be inspected")
return false, false, importSelectionDiagnostic(candidate.site, CodeImportInvalid, "import target could not be inspected")
}
if info.IsDir() && allowDirectory {
return false, true, nil
}
if !info.Mode().IsRegular() {
return false, importSelectionDiagnostic(candidate.site, CodeSourceNotRegular, "source is not a regular file")
return false, false, importSelectionDiagnostic(candidate.site, CodeSourceNotRegular, "source is not a regular file")
}
return false, nil
return false, false, nil
}
func excludedBasename(name string, patterns []string) bool {