rock-n-code/hummingbird-docc
1
0
Fork 0
Code Issues Pull Requests Releases 3 Activity

Improved the "callAsFunction(_: )" function for the PrepareURIPathUseCase use case in the library target.

Browse Source
This commit is contained in:
Javier Cicchelli
2025-09-30 16:34:48 +02:00
parent 2c3474a1b8
commit 0fea58d295
3 changed files with 82 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/HummingbirdDocC/Internal/Extensions/String+Helpers.swift
+5 -2
View File
@@ -36,8 +36,11 @@ extension String {
guard let matches = self.prefixMatch(of: pattern) else {
return nil
}
return matches.output.1 ?? .empty
guard let subtracted = matches.output.1 else {
return .empty
}
return subtracted
}
}
Sources/HummingbirdDocC/Internal/Use Cases/PrepareURIPathUseCase.swift
+57 -60
View File
@@ -13,17 +13,12 @@
import Foundation
import RegexBuilder
/// A use case that extracts data from a given URI path, essential for routing the documentation contents.
/// A use case that extracts a resource's information from a given URI path, essential for routing the documentation contents.
struct PrepareURIPathUseCase {
// MARK: Type aliases
/// A pseudo-type that contains the archive name, reference and URI path, plus the resource URI and relative paths used for routing the documentation contents.
typealias PreparedURIPaths = (archiveName: String, archiveReference: String, archivePath: String, resourcePath: String)
// MARK: Properties
/// A root path that suffixes the documentation resource.
/// A root path that prefixes the documentation resource.
private let uriRoot: String
// MARK: Initializers
@@ -39,44 +34,26 @@ struct PrepareURIPathUseCase {
// MARK: Functions
/// Extracts some necessary data essential for documentation contents routing from a given URI path.
///
/// The necessary data to extract from a given URI path is:
/// 1. the `DocC` documentation archive name;
/// 2. the `DocC` documentation archive reference;
/// 3. the `DocC` documentation archive URI path;
/// 4. the `DocC` documentation resource URI path.
///
/// Extracts resource's information that is essential for documentation contents routing from a given URI path.
/// > important: It is assumed that the `uriPath` parameter is a URI path that does not contain any percent encoded strings.
///
/// - Parameter uriPath: A URI path to extract the data from.
/// - Returns: A pseudo-type that contains the archive' name, reference and URI path, plus the resource URI paths.
func callAsFunction(_ uriPath: String) -> PreparedURIPaths? {
guard let uriRest = restOfURIPath(from: uriPath) else {
/// - Returns: A resource type containing all the relevant information
func callAsFunction(_ uriPath: String) -> Resource? {
guard let uriRest = uriRest(from: uriPath) else {
return nil
}
let archiveName = uriRest
.split(separator: .Path.forwardSlash)
.map(String.init)
.first
let archiveName = archiveName(from: uriRest)
let archiveReference: String = if let archiveName {
archiveName.lowercased()
} else {
.empty
}
let archivePath: String = if let archiveName {
.init(format: .Format.Path.archive, archiveName)
} else {
.empty
guard let relativePath = relativePath(from: uriRest, at: archiveName) else {
return nil
}
return (
archiveName ?? .empty,
archiveReference,
archivePath,
uriRest
return .init(
archiveName: archiveName,
relativePath: relativePath
)
}
@@ -88,40 +65,60 @@ private extension PrepareURIPathUseCase {
// MARK: Functions
/// Extracts the archive name from a given URI path.
///
/// > important: It is assumed that a given URI path is a relative URI path is prefixed with the `/` character and that contains the name of a `DocC`
/// documentation archive in its first component.
///
/// - Parameter uriPath: A relative URI path to extract the archive name from.
/// - Returns: An archive named extracted from a given URI path.
func archiveName(from uriPath: String) -> String {
uriPath
.split(separator: .Path.forwardSlash)
.map(String.init)
.first ?? .empty
}
/// Extracts the rest of the URI path from a given URI path against a defined URI root path.
///
/// A given URI path is matched against a regular expression, which is generated from a provided URI root path.
/// So this function would return either a string that represents a partial URI path, or a `nil` instance depending the result of the match between
/// the URI path and the regular expression:
/// * A `nil` instance in case there is no match;
/// * A `/` string in case there is a perfect match;
/// * A partial URI path prefixed with the `/` character in case there is an offset in the match.
///
/// - Parameter uriPath: A URI path to get the rest of the URI path from.
/// - Returns: A rest of the URI path prefixed by the `/`character in case where there is any offset path after extracting the root path from the given URI path or not. Otherwise, a `nil` value is returned.
func restOfURIPath(from uriPath: String) -> String? {
let restReference = Reference(String.self)
let uriPattern = Regex {
uriRoot
Optionally {
Capture(as: restReference) {
OneOrMore(.anyNonNewline)
} transform: { output in
String(output)
}
}
}
guard let matches = uriPath.prefixMatch(of: uriPattern) else {
func uriRest(from uriPath: String) -> String? {
guard let uriRest = uriPath.subtract(uriRoot) else {
return nil
}
guard let uriRest = matches.output.1 else {
return .Path.forwardSlash
guard !uriRest.isEmpty else {
return uriRest
}
guard uriRest.hasPrefix(.Path.forwardSlash) else {
return .init(format: .Format.Path.root, uriRest)
}
return uriRest
}
/// Extracts the relative URI path from a given URI path against the name of a documentation archive.
/// - Parameters:
/// - uriPath: A URI path to get the relative URI path from.
/// - archive: An archive name to subtract from a URI path.
/// - Returns: A relative URI path prefixed by the `/`character in case where there is any offset path after extracting the root path from the given URI path or not. Otherwise, a `nil` value is returned.
func relativePath(
from uriPath: String,
at archive: String
) -> String? {
guard !archive.isEmpty else {
return .Path.forwardSlash
}
let archivePath: String = .init(format: .Format.Path.root, archive)
guard let relativePath = uriPath.subtract(archivePath) else {
return nil
}
guard relativePath != .empty else {
return .empty
}
return relativePath
}
}