NSRegularExpression – Augmented Code

Adding prefixMap for expensive operations in Swift

Swift Foundation contains a lot of useful functions on collection types. In the context of this blog post we are interested in map(_:) and prefix(while:). Map is used for transforming collection elements and prefix(while:) for getting a sequence containing initial elements until the predicate is true. In some cases the predicate used in the prefix(while:) can be expensive, or we just want to combine the information in prefix and map functions. One of such examples is when we use NSRegularExpression. More specifically, let’s take an example of processing a list of strings while the regular expression has matches and then extracting a range from the string. A concrete example could be parsing Fastlane’s Fastfile for visualization purposes.

Fastlane is used a lot in the iOS community for automating development related tasks. Lanes are added to a Fastfile where every individual lane has a name and optionally a description.

	desc 'Build and upload app store build'
	desc 'Captures screenshots, builds the app, uploads to app store, and posts a message to slack'
	lane :appstore do
	capture_screenshots
	build_app
	upload_to_app_store
	slack
	end

view raw Fastfile hosted with ❤ by GitHub

If we would like to extract the lane name and description from the Fastfile then we can use regular expressions. The flow could be something like this: firstly, we can read the Fastfile contents, divide the file into lines and match lines with regular expressions. Second step is finding lines which contain a lane keyword. Then we could loop over preceding lines and collect lines which contain description. All in all, the logic for getting description could look like this:

	let descExpression = try! NSRegularExpression(pattern: "^\\sdesc [\"']{1}([^\"])[\"']{1}", options: [])
	// …
	let description = (0..<lineIndex)
	.reversed()
	.prefixMap({ index -> String? in
	// Get a line
	let line = lines[index]
	// Use regular expression
	guard let match = descExpression.firstMatch(in: line) else { return nil }
	// Regular expression contains a capture group, therefore looking for 2 ranges
	guard match.numberOfRanges >= 2 else { return nil }
	// When there are matches then extract description
	guard let range = Range(match.range(at: 1), in: line) else { return nil }
	return String(line[range])
	})
	.reversed()
	.joined(separator: "\n")

view raw FastfileParser.swift hosted with ❤ by GitHub

Now when we have seen a case where prefixMap can be useful, it is time to look into how it is implemented. The transform passed into the prefixMap function can return nil and the nil value means that the looping should be stopped and all the transformed elements should be returned. And yes, the implementation is pretty straight-forward.

	// Swift Foundation
	func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence
	func map<T>(_ transform: (Self.Element) throws -> T) rethrows -> [T]

	// prefixMap (new)
	extension Collection {
	@inlinable func prefixMap<T>(_ transform: (Self.Element) throws -> T?) rethrows -> [T] {
	var result = [T]()
	for element in self {
	if let transformedElement = try transform(element) {
	result.append(transformedElement)
	}
	else {
	break
	}
	}
	return result
	}
	}

view raw Collection.swift hosted with ❤ by GitHub

Summary

Foundation types can be extended with new functions easily. Although we could use prefix(while:) first followed with a map(_:) but sometimes we’ll just need to combine functionalities into a single function.

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.

Project

PrefixMapPlayground (Xcode 12.4)

Support me on Patreon

Donate with Paypal

Replacing multiple text tokens in Swift

Let’s see how to replace multiple tokens in string. As an example problem to solve we will use this string:
The quick <color_1> <animal_1> jumps over the lazy <animal_2>

String extension for replacing tokens

Token’s format is < text _ numbers > what can be turned into regular expression: <[:alpha:]+_{1}[:digit:]+>.

We’ll extend string and add a function what takes in regular expression and closure responsible of providing replacement strings. For finding tokens, we’ll use NSRegularExpression and get all the matches in the string. Next step is to reverse enumerate matches and replace tokens. Reverse enumerating is required it ensures that token ranges are constant. If we would start replacing from the first match, then all the succeeding ranges should be shifted based on the length difference of all the preceding tokens and replacements. In this case reduce is convenient because we can enumerate all the matches and then mutating the copy of the initial string with very few lines. Another aspect to note is that NSRegularExpression uses NSRange instead of <a rel="noreferrer noopener" aria-label="RangeRange<String.Index>. Therefore we need to convert ranges from one type to another making sure character indexes match.
This function can now be used with custom logic when providing replacements. For example: we can have a simple mapping or even returning the same replacement string.

	let text = "The quick <color_1> <animal_1> jumps over the lazy <animal_2>"
	let replacementMap = ["<animal_1>": "fox", "<animal_2>": "dog", "<color_1>": "brown"]

	extension String {
	func replacingOccurrences(matchingPattern pattern: String, replacementProvider: (String) -> String?) -> String {
	let expression = try! NSRegularExpression(pattern: pattern, options: [])
	let matches = expression.matches(in: self, options: [], range: NSRange(startIndex..<endIndex, in: self))
	return matches.reversed().reduce(into: self) { (current, result) in
	let range = Range(result.range, in: current)!
	let token = String(current[range])
	guard let replacement = replacementProvider(token) else { return }
	current.replaceSubrange(range, with: replacement)
	}
	}
	}

	let finalString1 = text.replacingOccurrences(matchingPattern: "<[:alpha:]+_{1}[:digit:]+>", replacementProvider: { replacementMap[$0] })
	let finalString2 = text.replacingOccurrences(matchingPattern: "<[:alpha:]+_{1}[:digit:]+>", replacementProvider: { _ in "REPLACEMENT" })
	print(text)
	print(finalString1) // The quick brown fox jumps over the lazy dog
	print(finalString2) // The quick REPLACEMENT REPLACEMENT jumps over the lazy REPLACEMENT

view raw ReplacingTokens.swift hosted with ❤ by GitHub

String extension replacing tokens matching a pattern.

Summary

When we would like to do multiple replacements in a string, then one of the approaches is to get all the replacement ranges and then reverse enumerating the ranges and making replacements. In this way we can avoid having complex code trying to adjust based on the length difference of the source and replacement string.

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.