Support interpolation in @blk_str

Author: omus

src/BlockScalars.jl

@@ -146,7 +146,49 @@ function block(str::AbstractString, style::Symbol, chomp::Symbol)
 end
 
 macro blk_str(str::AbstractString, indicators::AbstractString="")
-    return block(str, indicators)
+    parsed = interpolate(str)
+
+    # When no string interpolation needs to take place we can just process the multiline
+    # string during parse time. If string interpolation needs to take place we'll evaluate
+    # the multiline string at runtime so that we can process after interpolation has taken
+    # place.
+    result = if parsed isa String
+        block(unescape_string(parsed), indicators)
+    else
+        Expr(:call, :(BlockScalars.block), parsed, indicators)
+    end
+
+    return esc(result)
+end
+
+function interpolate(str::AbstractString)
+    components = []
+    start = 1
+    lastind = lastindex(str)
+
+    state = iterate(str)
+    while state !== nothing
+        c, i = state
+
+        if c == '$'
+            ending = prevind(str, i, 2)
+            start <= ending && push!(components, SubString(str, start, ending))
+
+            expr, i = Meta.parse(str, i; greedy=false)
+            push!(components, expr)
+            start = i
+        end
+
+        state = iterate(str, i)
+    end
+
+    # When interpolation isn't used we can just return the original string
+    start == 1 && return str
+
+    ending = lastind
+    start <= ending && push!(components, SubString(str, start, ending))
+
+    return Expr(:string, components...)
 end
 
 end

test/runtests.jl

@@ -1,4 +1,4 @@
-using BlockScalars: @blk_str, block
+using BlockScalars: BlockScalars, @blk_str, block, interpolate
 using Test
 using YAML: YAML
 
@@ -114,14 +114,32 @@ end
         end
     end
 
+    @testset "interpolate" begin
+        @test interpolate("x") == "x"
+        @test interpolate("\$x") == Expr(:string, :x)
+        @test interpolate("\$(x)") == Expr(:string, :x)
+        @test interpolate("\$(\"x\")") == Expr(:string, "x")
+
+        @test interpolate("<\$x>") == Expr(:string, "<", :x, ">")
+        @test interpolate("<\$(x)>") == Expr(:string, "<", :x, ">")
+
+        # The quoting in these examples can result in exceptions being raised during parsing
+        # if handled incorrectly.
+        @test interpolate("\"\\n\"") == "\"\\n\""
+        @test interpolate("\$(join([\"a\", \"b\"], \", \"))") == Expr(:string, :(join(["a", "b"], ", ")))
+    end
 
     @testset "@blk_str" begin
-        @testset "invalid indicators" begin
-            @test_throws LoadError macroexpand(@__MODULE__, :(@blk_str "" "fs_"))  # Too many indicators
-            @test_throws LoadError macroexpand(@__MODULE__, :(@blk_str "" "sf"))  # Order matters
-            @test_throws LoadError macroexpand(@__MODULE__, :(@blk_str "" "_s"))  # Invalid style
-            @test_throws LoadError macroexpand(@__MODULE__, :(@blk_str "" "f_"))  # Invalid chomp
-            @test_throws LoadError macroexpand(@__MODULE__, :(@blk_str "" "_"))   # Invalid style/chomp
+        @testset "quoting" begin
+            # Use of double-quotes could cause failure if not handled properly:
+            # `syntax: incomplete: invalid string syntax`
+            @test blk"\"\n\"" == "\" \""
+        end
+
+        @testset "string-interpolation" begin
+            # If processing would accidentally take place in the interpolated code then
+            # we could see "a b " as the result.
+            @test blk"""$(join(("a", "b") .* "\n", ""))"""fc == "a b\n"
         end
     end
 end