Swift: How to cut off text from a longer text if initator and terminator is provided as regex? - swift

Question

How to get from this: "{\n \"DNAHeader\": {},\n \"ItemsSaleable\": []\n}\n"
this: "\"DNAHeader\":{},\"ItemsSaleable\":[]"
I have for initiator this regex:
"<OWSP>{<OWSP>"
for terminator this:
"<OWSP>}<OWSP>"
where <OWSP> is optional white space, the same as in Swift regex \s* is.
I convert them to the Swift equivalent:
if let group = groupOrItem as? Group,
let initiator = group.typeSyntax?.initiator?.literal.literalValue?.replacingOccurrences(of: "<OWSP>", with: "\\s*"),
let terminator = group.typeSyntax?.terminator?.literal.literalValue?.replacingOccurrences(of: "<OWSP>", with: "\\s*")
{
let captureString = "(.*?)"
let regexString = initiator + captureString + terminator
let regexPattern = "#" + regexString + "#"
Then regex pattern looks like this:
(lldb) po regexString
"\\s*{\\s*(.*?)\\s*}\\s*"
Question, how to apply it, how to cut off meaningful inner text? I tried this,
var childText = text.replacingOccurrences(of: regexPattern, with: "$1", options: .regularExpression).filter { !$0.isWhitespace }
but does not remove the initiator / terminator texts, like the { and } parts from here:
(lldb) po text
"{\n \"DNAHeader\": {},\n \"ItemsSaleable\": []\n}\n"
(lldb) po childText
"{\"DNAHeader\":{},\"ItemsSaleable\":[]}"

Answer 1

As said in comments, you currently have JSON (but you say to not focus on it, but...), which make the Regex construction quite hard.
As I suspect a Stream, I create fake tests values for that, but it's not necessary the case:
let startSeparator = "<OWS>{<OWS>"
let endSeparator = "<OWS>}<OWS>"
//Fake structure
struct Object: Codable {
let id: Int
let NDAHeader: Header
let ItemsSaleable: [Saleable]
}
struct Header: Codable {}
struct Saleable: Codable {}
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let str0 = embedStr(codable: Object(id: 0, NDAHeader: Header(), ItemsSaleable: []), with: encoder)
let str1 = embedStr(codable: Object(id: 1, NDAHeader: Header(), ItemsSaleable: []), with: encoder)
let str2 = embedStr(codable: Object(id: 2, NDAHeader: Header(), ItemsSaleable: []), with: encoder)
let str3 = embedStr(codable: Object(id: 3, NDAHeader: Header(), ItemsSaleable: []), with: encoder)
//Replace starting `{` & closing `}` of JSON with surroundnig <OWS>
func embedStr(codable: Codable, with encoder: JSONEncoder) -> String {
let jsonData = try! encoder.encode(codable)
var value = String(data: jsonData, encoding: .utf8)!
value = startSeparator + String(value.dropFirst())
value = String(value.dropLast()) + endSeparator
return value
}
//Create a fake stream, by joining multiple JSON values, and "cut it"
func concate(strs: [String], dropStart: Int, dropEnd: Int) -> String {
var value = strs.joined()
value = String(value.dropFirst(dropStart))
value = String(value.dropLast(dropEnd))
return value
}
//Fake Streams
let concate0 = concate(strs: [str0], dropStart: 0, dropEnd: 0)
let concate1 = concate(strs: [str0, str1, str2], dropStart: 13, dropEnd: 13)
let concate2 = concate(strs: [str0, str1, str2, str3], dropStart: 20, dropEnd: 13)
The "extract/find" code:
//Here, if it's a stream, you could return the rest of `value`, because it might be the start of a message, and to concatenate with the next part of the stream
//Side note, if it's a `Data`, `range(of:range:)` can be called on `Data`, avoiding you a strinigification if possible (like going back to JSON to remove the pretty printed format)
func analyze(str: String, found: ((String) -> Void)) {
var value = str
var start = value.range(of: startSeparator)
//Better coding might be applied, it's more a proof of concept, but you should be able to grasp the logic:
// Search for START to next END, return that captured part with closure `found`
// Keep searching for the rest of the string.
guard start != nil else { return }
var end = value.range(of: endSeparator, range: start!.upperBound..<value.endIndex)
while (start != nil && end != nil) {
let sub = value[start!.upperBound..<end!.lowerBound]
found("{" + String(sub) + "}") //Here is hard encoded the part surrounded by <OWS> tag
value = String(value[end!.upperBound...])
start = value.range(of: startSeparator)
if start != nil {
end = value.range(of: endSeparator, range: start!.upperBound..<value.endIndex)
} else {
end = nil
}
}
}
To test:
func test(str: String) {
print("In \(str.debugDescription)")
analyze(str: str) { match in
print("Found \(match.debugDescription)")
//The next part isn't beautiful, but it's one of the safest way to get rid of spaces/\n which are part of the pretty printed
let withouthPrettyPrintedData = try! (JSONSerialization.data(withJSONObject: try! JSONSerialization.jsonObject(with: Data(match.utf8))))
print("Cleaned: \(String(data: withouthPrettyPrintedData, encoding: .utf8)!.debugDescription)")
}
print("")
}
//Test the fake streams
[concate0, concate1, concate2].forEach {
test(str: $0)
}
I used debugDescription in order to see in console the "\n".
Output:
$>In "<OWS>{<OWS>\n \"id\" : 0,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n<OWS>}<OWS>"
$>Found "{\n \"id\" : 0,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n}"
$>Cleaned: "{\"id\":0,\"ItemsSaleable\":[],\"NDAHeader\":{}}"
$>In " \"id\" : 0,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n<OWS>}<OWS><OWS>{<OWS>\n \"id\" : 1,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n<OWS>}<OWS><OWS>{<OWS>\n \"id\" : 2,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n "
$>Found "{\n \"id\" : 1,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n}"
$>Cleaned: "{\"id\":1,\"ItemsSaleable\":[],\"NDAHeader\":{}}"
$>In " 0,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n<OWS>}<OWS><OWS>{<OWS>\n \"id\" : 1,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n<OWS>}<OWS><OWS>{<OWS>\n \"id\" : 2,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n<OWS>}<OWS><OWS>{<OWS>\n \"id\" : 3,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n "
$>Found "{\n \"id\" : 1,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n}"
$>Cleaned: "{\"id\":1,\"ItemsSaleable\":[],\"NDAHeader\":{}}"
$>Found "{\n \"id\" : 2,\n \"ItemsSaleable\" : [\n\n ],\n \"NDAHeader\" : {\n\n }\n}"
$>Cleaned: "{\"id\":2,\"ItemsSaleable\":[],\"NDAHeader\":{}}"

Answer 2

If you can use RegexBuilder, available from iOS 16 and macOS 13, the following code works (see function extracted()):
import RegexBuilder
import SwiftUI
struct MyView: View {
let text = "{\n \"DNAHeader\": {},\n \"ItemsSaleable\": []\n}\n"
var body: some View {
VStack {
Text(text)
Text(extracted(text) ?? "Not found")
}
}
private func extracted(_ text: String) -> String? {
let initiator = Regex {
ZeroOrMore(.horizontalWhitespace)
"{"
ZeroOrMore(.horizontalWhitespace)
}
let terminator = Regex {
ZeroOrMore(.horizontalWhitespace)
"}"
ZeroOrMore(.horizontalWhitespace)
}
// Read the text and capture only what's in between the
// initiator and terminator
let searchJSON = Regex {
initiator
Capture { OneOrMore(.any) } // The real contents
terminator
}
// Extract the whole string and the extracted string
if let match = text.firstMatch(of: searchJSON) {
let (wholeMatch, extractedString) = match.output
print(wholeMatch)
// Replace whitespaces and line feeds before returning
return String(extractedString
.replacing("\n", with: "")
.replacing(" ", with: ""))
} else {
return nil
}
}
}