don't copy regex match strings (#15)

* don't copy regex match strings

* more docs for SVRegexMatch

* AbstractMatch requires Julia 1.6

* bugfixes and tests

Author: stevengj

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - "1.3"
+          - "1.6"
           - "1"
           - "nightly"
         os:

Project.toml

@@ -4,7 +4,7 @@ authors = ["Steven G. Johnson <[email protected]>"]
 version = "1.1.2"
 
 [compat]
-julia = "1.3"
+julia = "1.6"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

README.md

@@ -25,9 +25,9 @@ julia> s = StringView(b) # does not make a copy
 "foobar"
 
 julia> collect(eachmatch(r"[aeiou]+", s))
-2-element Array{RegexMatch,1}:
- RegexMatch("oo")
- RegexMatch("a")
+2-element Vector{SVRegexMatch{StringView{Vector{UInt8}}}}:
+ SVRegexMatch("oo")
+ SVRegexMatch("a")
 
 julia> StringView(@view b[1:3]) # also works for subarrays, with no copy
 "foo"

src/StringViews.jl

@@ -10,7 +10,7 @@ a `StringView` is intended to be usable in any context where you might
 have otherwise used `String`.
 """
 module StringViews
-export StringView
+export StringView, SVRegexMatch
 
 """
     StringView{T<:AbstractVector{UInt8}} <: AbstractString

src/regex.jl

@@ -18,7 +18,7 @@ function Base.endswith(s::DenseStringViewAndSub, r::Regex)
     return PCRE.exec_r(r.regex, s, 0, r.match_options | PCRE.ENDANCHORED)
 end
 
-function Base.match(re::Regex, str::DenseStringViewAndSub, idx::Integer, add_opts::UInt32=UInt32(0))
+function Base.match(re::Regex, str::T, idx::Integer, add_opts::UInt32=UInt32(0)) where {T<:DenseStringViewAndSub}
     Base.compile(re)
     opts = re.match_options | add_opts
     matched, data = PCRE.exec_r_data(re.regex, str, idx-1, opts)
@@ -29,11 +29,11 @@ function Base.match(re::Regex, str::DenseStringViewAndSub, idx::Integer, add_opt
     n = div(PCRE.ovec_length(data), 2) - 1
     p = PCRE.ovec_ptr(data)
     mat = SubString(str, unsafe_load(p, 1)+1, prevind(str, unsafe_load(p, 2)+1))
-    cap = Union{Nothing,SubString{String}}[unsafe_load(p,2i+1) == PCRE.UNSET ? nothing :
+    cap = Union{Nothing,SubString{T}}[unsafe_load(p,2i+1) == PCRE.UNSET ? nothing :
                                            SubString(str, unsafe_load(p,2i+1)+1,
                                            prevind(str, unsafe_load(p,2i+2)+1)) for i=1:n]
     off = Int[ unsafe_load(p,2i+1)+1 for i=1:n ]
-    result = RegexMatch(mat, cap, unsafe_load(p,1)+1, off, re)
+    result = SVRegexMatch(mat, cap, unsafe_load(p,1)+1, off, re)
     PCRE.free_match_data(data)
     return result
 end
@@ -70,7 +70,8 @@ struct RegexMatchIterator{T<:DenseStringViewAndSub}
     overlap::Bool
 end
 Base.compile(itr::RegexMatchIterator) = (compile(itr.regex); itr)
-Base.eltype(::Type{<:RegexMatchIterator}) = RegexMatch
+Base.eltype(::Type{RegexMatchIterator{T}}) where {T<:DenseStringView} = SVRegexMatch{T}
+Base.eltype(::Type{RegexMatchIterator{SubString{T}}}) where {T<:DenseStringView} = SVRegexMatch{T}
 Base.IteratorSize(::Type{<:RegexMatchIterator}) = Base.SizeUnknown()
 
 function Base.iterate(itr::RegexMatchIterator, (offset,prevempty)=(1,false))
@@ -115,3 +116,80 @@ function PCRE.exec(re, subject::DenseStringViewAndSub, offset, options, match_da
     rc < -2 && error("PCRE.exec error: $(PCRE.err_message(rc))")
     return rc >= 0
 end
+
+#####################################################################
+# need to duplicate this code from Base because of julia#48617:
+"""
+    SVRegexMatch <: AbstractMatch
+
+This type is identical to `RegexMatch` (in Julia `Base`) except that the
+`match` is a `SubString` of a `StringView` instead of a `String`.
+
+A type representing a single match to a `Regex` found in a string.
+Typically created from the [`match`](@ref) function.
+
+* The `match` field stores the substring of the entire matched string.
+* The `captures` field stores the substrings for each capture group, indexed by number.
+  To index by capture group name, the entire match object should be indexed instead,
+  as shown in the examples.
+* The location of the start of the match is stored in the `offset` field.
+* The `offsets` field stores the locations of the start of each capture group,
+  with 0 denoting a group that was not captured.
+
+This type can be used as an iterator over the capture groups of the `Regex`,
+yielding the substrings captured in each group.
+Because of this, the captures of a match can be destructured.
+If a group was not captured, `nothing` will be yielded instead of a substring.
+"""
+struct SVRegexMatch{T<:DenseStringView} <: AbstractMatch
+    match::SubString{T}
+    captures::Vector{Union{Nothing,SubString{T}}}
+    offset::Int
+    offsets::Vector{Int}
+    regex::Regex
+end
+SVRegexMatch(match::SubString{T}, captures, offset, offsets, regex) where {T<:DenseStringViewAndSub} =
+    SVRegexMatch{T}(match, captures, offset, offsets, regex)
+
+function Base.keys(m::SVRegexMatch)
+    idx_to_capture_name = PCRE.capture_names(m.regex.regex)
+    return map(eachindex(m.captures)) do i
+        # If the capture group is named, return it's name, else return it's index
+        get(idx_to_capture_name, i, i)
+    end
+end
+
+function Base.show(io::IO, m::SVRegexMatch)
+    print(io, "SVRegexMatch(")
+    show(io, m.match)
+    capture_keys = keys(m)
+    if !isempty(capture_keys)
+        print(io, ", ")
+        for (i, capture_name) in enumerate(capture_keys)
+            print(io, capture_name, "=")
+            show(io, m.captures[i])
+            if i < length(m)
+                print(io, ", ")
+            end
+        end
+    end
+    print(io, ")")
+end
+
+# Capture group extraction
+Base.getindex(m::SVRegexMatch, idx::Integer) = m.captures[idx]
+function Base.getindex(m::SVRegexMatch, name::Union{AbstractString,Symbol})
+    idx = PCRE.substring_number_from_name(m.regex.regex, name)
+    idx <= 0 && error("no capture group named $name found in regex")
+    m[idx]
+end
+
+Base.haskey(m::SVRegexMatch, idx::Integer) = idx in eachindex(m.captures)
+function Base.haskey(m::SVRegexMatch, name::Union{AbstractString,Symbol})
+    idx = PCRE.substring_number_from_name(m.regex.regex, name)
+    return idx > 0
+end
+
+Base.iterate(m::SVRegexMatch, args...) = iterate(m.captures, args...)
+Base.length(m::SVRegexMatch) = length(m.captures)
+Base.eltype(m::SVRegexMatch) = eltype(m.captures)

test/runtests.jl

@@ -82,8 +82,24 @@ end
     end
     @test findnext(r"[aeiou]+", s, 1) == 2:3
     @test findnext(r"[aeiou]+", ss, 1) == 1:2
+
+    sv = StringView(codeunits("foo 1234 bar"))
+    @test match(r"[0-9]+", sv).match.string === sv
+    @test eltype(eachmatch(r"[0-9]+", sv)) == SVRegexMatch{typeof(sv)}
+end
+
+@testset "named subpatterns" begin
+    m = match(r"(?<a>.)(.)(?<b>.)", StringView(codeunits("xyz")))
+    @test haskey(m, :a)
+    @test haskey(m, 2)
+    @test haskey(m, "b")
+    @test !haskey(m, "foo")
+    @test (m[:a], m[2], m["b"]) == ("x", "y", "z")
+    @test sprint(show, m) == "SVRegexMatch(\"xyz\", a=\"x\", 2=\"y\", b=\"z\")"
+    @test keys(m) == ["a", 2, "b"]
 end
 
+
 @testset "parsing" begin
     for val in (true, 1234, 1234.5, 1234.5f0, 4.5+3.25im)
         sval = string(val)