Implement TOML.parse(::IO) and add more tests for (JuliaLang#37278)

TOML.(try)parse(file) entrypoints.

stdlib/TOML/src/TOML.jl

@@ -30,10 +30,10 @@ const Parser = Internals.Parser
     parsefile(f::AbstractString)
     parsefile(p::Parser, f::AbstractString)
 
-Parses a file `f` and returns the resulting table (dictionary). Throws a
+Parse file `f` and return the resulting table (dictionary). Throw a
 [`ParserError`](@ref) upon failure.
 
-See also [`TOML.tryparsefile`](@ref)
+See also: [`TOML.tryparsefile`](@ref)
 """
 parsefile(f::AbstractString) =
     Internals.parse(Parser(read(f, String); filepath=abspath(f)))
@@ -44,43 +44,47 @@ parsefile(p::Parser, f::AbstractString) =
     tryparsefile(f::AbstractString)
     tryparsefile(p::Parser, f::AbstractString)
 
-Parses a file `f` and returns the resulting table (dictionary). Returns a
+Parse file `f` and return the resulting table (dictionary). Return a
 [`ParserError`](@ref) upon failure.
 
-See also [`TOML.parsefile`](@ref)
+See also: [`TOML.parsefile`](@ref)
 """
 tryparsefile(f::AbstractString) =
     Internals.tryparse(Parser(read(f, String); filepath=abspath(f)))
 tryparsefile(p::Parser, f::AbstractString) =
     Internals.tryparse(Internals.reinit!(p, read(f, String); filepath=abspath(f)))
 
 """
-    parse(str::AbstractString)
-    parse(p::Parser, str::AbstractString)
+    parse(x::Union{AbstractString, IO})
+    parse(p::Parser, x::Union{AbstractString, IO})
 
-Parses a string `str` and returns the resulting table (dictionary). Returns a
-[`ParserError`](@ref) upon failure.
+Parse the string  or stream `x`, and return the resulting table (dictionary).
+Throw a [`ParserError`](@ref) upon failure.
 
-See also [`TOML.tryparse`](@ref)
+See also: [`TOML.tryparse`](@ref)
 """
 parse(str::AbstractString) =
     Internals.parse(Parser(String(str)))
 parse(p::Parser, str::AbstractString) =
     Internals.parse(Internals.reinit!(p, String(str)))
+parse(io::IO) = parse(read(io, String))
+parse(p::Parser, io::IO) = parse(p, read(io, String))
 
 """
-    tryparse(str::AbstractString)
-    tryparse(p::Parser, str::AbstractString)
+    tryparse(x::Union{AbstractString, IO})
+    tryparse(p::Parser, x::Union{AbstractString, IO})
 
-Parses a string `str` and returns the resulting table (dictionary). Returns a
-[`ParserError`](@ref) upon failure.
+Parse the string or stream `x`, and return the resulting table (dictionary).
+Return a [`ParserError`](@ref) upon failure.
 
-See also [`TOML.parse`](@ref)
+See also: [`TOML.parse`](@ref)
 """
 tryparse(str::AbstractString) =
     Internals.tryparse(Parser(String(str)))
 tryparse(p::Parser, str::AbstractString) =
     Internals.tryparse(Internals.reinit!(p, String(str)))
+tryparse(io::IO) = tryparse(read(io, String))
+tryparse(p::Parser, io::IO) = tryparse(p, read(io, String))
 
 """
     ParserError

stdlib/TOML/test/parse.jl

@@ -0,0 +1,46 @@
+using TOML, Test
+using TOML: ParserError
+
+@testset "TOML.(try)parse(file) entrypoints" begin
+    dict = Dict{String,Any}("a" => 1)
+    str = "a = 1"; invalid_str = "a"
+    path, io = mktemp(); write(io, str); close(io)
+    invalid_path, io = mktemp(); write(io, invalid_str); close(io)
+    p = TOML.Parser()
+    # TOML.parse
+    @test TOML.parse(str) == TOML.parse(SubString(str)) ==
+          TOML.parse(IOBuffer(str)) ==
+          TOML.parse(p, str) == TOML.parse(p, SubString(str)) ==
+          TOML.parse(p, IOBuffer(str)) == dict
+    @test_throws ParserError TOML.parse(invalid_str)
+    @test_throws ParserError TOML.parse(SubString(invalid_str))
+    @test_throws ParserError TOML.parse(IOBuffer(invalid_str))
+    @test_throws ParserError TOML.parse(p, invalid_str)
+    @test_throws ParserError TOML.parse(p, SubString(invalid_str))
+    @test_throws ParserError TOML.parse(p, IOBuffer(invalid_str))
+    # TOML.tryparse
+    @test TOML.tryparse(str) == TOML.tryparse(SubString(str)) ==
+          TOML.tryparse(IOBuffer(str)) ==
+          TOML.tryparse(p, str) == TOML.tryparse(p, SubString(str)) ==
+          TOML.tryparse(p, IOBuffer(str)) == dict
+    @test TOML.tryparse(invalid_str) isa ParserError
+    @test TOML.tryparse(SubString(invalid_str)) isa ParserError
+    @test TOML.tryparse(IOBuffer(invalid_str)) isa ParserError
+    @test TOML.tryparse(p, invalid_str) isa ParserError
+    @test TOML.tryparse(p, SubString(invalid_str)) isa ParserError
+    @test TOML.tryparse(p, IOBuffer(invalid_str)) isa ParserError
+    # TOML.parsefile
+    @test TOML.parsefile(path) == TOML.parsefile(SubString(path)) ==
+          TOML.parsefile(p, path) == TOML.parsefile(p, SubString(path)) == dict
+    @test_throws ParserError TOML.parsefile(invalid_path)
+    @test_throws ParserError TOML.parsefile(SubString(invalid_path))
+    @test_throws ParserError TOML.parsefile(p, invalid_path)
+    @test_throws ParserError TOML.parsefile(p, SubString(invalid_path))
+    # TOML.tryparsefile
+    @test TOML.tryparsefile(path) == TOML.tryparsefile(SubString(path)) ==
+          TOML.tryparsefile(p, path) == TOML.tryparsefile(p, SubString(path)) == dict
+    @test TOML.tryparsefile(invalid_path) isa ParserError
+    @test TOML.tryparsefile(SubString(invalid_path)) isa ParserError
+    @test TOML.tryparsefile(p, invalid_path) isa ParserError
+    @test TOML.tryparsefile(p, SubString(invalid_path)) isa ParserError
+end

stdlib/TOML/test/runtests.jl

@@ -19,5 +19,6 @@ include("values.jl")
 include("invalids.jl")
 include("error_printing.jl")
 include("print.jl")
+include("parse.jl")
 
-@inferred TOML.parse("foo = 3")
+@inferred TOML.parse("foo = 3")