more updates for 0.7 (#20)

* more updates for 0.7

* fix codeunits for 0.6

* fix method ambiguities

Author: stevengj

REQUIRE

@@ -1,2 +1,2 @@
 julia 0.6
-Compat 0.8.0
+Compat 0.62.0

src/LaTeXStrings.jl

@@ -1,72 +1,87 @@
 __precompile__()
 
+"""
+The LaTeXStrings module exists mainly to make LaTeX equations easier to type as
+literal strings, and so that the resulting strings display as formatted equations
+in supporting environments like IJulia.
+
+See in particular the `LaTeXString` type and the `L"..."` constructor macro.
+"""
 module LaTeXStrings
 export LaTeXString, latexstring, @L_str, @L_mstr
-
 using Compat
-import Compat.String
 
 # IJulia supports LaTeX output for any object with a text/latex
 # writemime method, but these are annoying to type as string literals
 # in Julia because of all the escaping required, e.g. "\$\\alpha +
 # \\beta\$".  To simplify this, we add a new string type with a macro
 # constructor, so that one can simply do L"$\alpha + \beta$".
 
+@doc raw"""
+A `LaTeXString` is a string type whose contents represent a fragment of LaTeX code,
+typically containing an equation (`$...$`).   In certain environments (e.g. IJulia)
+this will display with LaTeX-like formatting.   For the most part, you can use
+a `LaTeXString` object in any context that expects an `AbstractString` object.
+
+The `L"..."` macro is convenient for constructing `LaTeXString` objects, because
+it eliminates the need to escape backslashes and dollar signs, and implicitly inserts
+dollar signs around the string if none are present.  For example, `L"$\alpha$"`, `L"\alpha"`,
+and `LaTeXString("\$\\alpha\$")` are all equivalent.
+"""
 struct LaTeXString <: AbstractString
     s::String
 end
 
-# coercing constructor:
+"""
+    latexstring(args...)
+
+Similar to `string(args...)`, but generates a `LaTeXString` instead of a `String`.
+"""
+latexstring(args...) = latexstring(string(args...))
 function latexstring(s::String)
     # the only point of using LaTeXString to represent equations, since
     # IJulia doesn't support LaTeX output other than equations, so add $'s
     # around the string if they aren't there (ignoring \$)
-    return ismatch(r"[^\\]\$|^\$", s) ?
-        LaTeXString(s) :  LaTeXString(string("\$", s, "\$"))
+    return occursin(r"[^\\]\$|^\$", s) ? LaTeXString(s) :  LaTeXString(string('\$', s, '\$'))
 end
 latexstring(s::AbstractString) = latexstring(String(s))
-latexstring(args...) = latexstring(string(args...))
 
 macro L_str(s, flags...) latexstring(s) end
 macro L_mstr(s, flags...) latexstring(s) end
 
-import Base: write, endof, getindex, sizeof, search, rsearch, isvalid, next, length, IOBuffer, pointer
-@compat import Base.show
-
-write(io::IO, s::LaTeXString) = write(io, s.s)
-@compat show(io::IO, ::MIME"application/x-latex", s::LaTeXString) = write(io, s)
-@compat show(io::IO, ::MIME"text/latex", s::LaTeXString) = write(io, s)
-
-function show(io::IO, s::LaTeXString)
+Base.write(io::IO, s::LaTeXString) = write(io, s.s)
+Base.show(io::IO, ::MIME"application/x-latex", s::LaTeXString) = write(io, s)
+Base.show(io::IO, ::MIME"text/latex", s::LaTeXString) = write(io, s)
+function Base.show(io::IO, s::LaTeXString)
     print(io, "L")
     Base.print_quoted_literal(io, s.s)
 end
 
-if isdefined(Base, :bytestring)
-    import Base: bytestring
-    bytestring(s::LaTeXString) = bytestring(s.s)
+Compat.firstindex(s::LaTeXString) = Compat.firstindex(s.s)
+Compat.lastindex(s::LaTeXString) = Compat.lastindex(s.s)
+Base.start(s::LaTeXString) = start(s.s)
+Base.next(s::LaTeXString, i) = next(s.s, i)
+Base.done(s::LaTeXString, i) = done(s.s, i)
+if isdefined(Base, :iterate)
+    Base.iterate(s::LaTeXString, i::Int) = iterate(s.s, i)
 end
-
-endof(s::LaTeXString) = endof(s.s)
-next(s::LaTeXString, i::Int) = next(s.s, i)
-length(s::LaTeXString) = length(s.s)
-getindex(s::LaTeXString, i::Int) = getindex(s.s, i)
-getindex(s::LaTeXString, i::Integer) = getindex(s.s, i)
-getindex(s::LaTeXString, i::Real) = getindex(s.s, i)
-getindex(s::LaTeXString, i::UnitRange{Int}) = getindex(s.s, i)
-getindex{T<:Integer}(s::LaTeXString, i::UnitRange{T}) = getindex(s.s, i)
-getindex(s::LaTeXString, i::AbstractVector) = getindex(s.s, i)
-sizeof(s::LaTeXString) = sizeof(s.s)
-search(s::LaTeXString, c::Char, i::Integer) = search(s.s, c, i)
-rsearch(s::LaTeXString, c::Char, i::Integer) = rsearch(s.s, c, i)
-isvalid(s::LaTeXString, i::Integer) = isvalid(s.s, i)
-pointer(s::LaTeXString) = pointer(s.s)
-IOBuffer(s::LaTeXString) = IOBuffer(s.s)
-
-import Base.convert
-const unsafe_convert = Base.convert
-
-@compat unsafe_convert(T::Union{Type{Ptr{UInt8}},Type{Ptr{Int8}}}, s::LaTeXString) = convert(T, s.s)
-unsafe_convert(::Type{Cstring}, s::LaTeXString) = unsafe_convert(Cstring, s.s)
+Base.nextind(s::LaTeXString, i::Int) = nextind(s.s, i)
+Base.prevind(s::LaTeXString, i::Int) = prevind(s.s, i)
+Base.eachindex(s::LaTeXString) = eachindex(s.s)
+Base.length(s::LaTeXString) = length(s.s)
+Base.getindex(s::LaTeXString, i::Integer) = getindex(s.s, i)
+Base.getindex(s::LaTeXString, i::Int) = getindex(s.s, i) # for method ambig in Julia 0.6
+Base.getindex(s::LaTeXString, i::UnitRange{Int}) = getindex(s.s, i)
+Base.getindex(s::LaTeXString, i::UnitRange{<:Integer}) = getindex(s.s, i)
+Base.getindex(s::LaTeXString, i::AbstractVector{<:Integer}) = getindex(s.s, i)
+Compat.codeunit(s::LaTeXString, i::Integer) = codeunit(s.s, i)
+Compat.codeunit(s::LaTeXString) = codeunit(s.s)
+Compat.ncodeunits(s::LaTeXString) = ncodeunits(s.s)
+Compat.codeunits(s::LaTeXString) = codeunits(s.s)
+Base.sizeof(s::LaTeXString) = sizeof(s.s)
+Base.isvalid(s::LaTeXString, i::Integer) = isvalid(s.s, i)
+Base.pointer(s::LaTeXString) = pointer(s.s)
+Base.IOBuffer(s::LaTeXString) = IOBuffer(s.s)
+Base.unsafe_convert(T::Union{Type{Ptr{UInt8}},Type{Ptr{Int8}},Cstring}, s::LaTeXString) = Base.unsafe_convert(T, s.s)
 
 end # module

test/runtests.jl

@@ -1,13 +1,23 @@
 using LaTeXStrings, Compat
-using Base.Test
+using Compat.Test
 
-# write your own tests here
 tst1 = L"an equation: $\alpha^2$"
-tst1u = Compat.UTF8String(tst1)
-@test tst1 == "an equation: \$\\alpha^2\$" == tst1u
+tst1s = String(tst1)
+@test tst1 == "an equation: \$\\alpha^2\$" == tst1s
 @test L"\alpha^2" == "\$\\alpha^2\$"
-@test stringmime("text/latex", tst1) == tst1u
-@test sprint(show, "text/latex", tst1) == tst1u
-@test latexstring(tst1u) == tst1 == LaTeXString(tst1u)
+@test repr("text/latex", tst1) == tst1s
+@test sprint(show, "text/latex", tst1) == tst1s
+@test latexstring(tst1s) == tst1 == LaTeXString(tst1s)
 
 @test ccall(:strlen, Csize_t, (Cstring,), tst1) == ccall(:strlen, Csize_t, (Ptr{UInt8},), tst1) == sizeof(tst1)
+
+for f in (length, eachindex, pointer, collect, ncodeunits, codeunits)
+    @test f(tst1) == f(tst1.s)
+end
+@test nextind(tst1, 1) == prevind(tst1, 3) == 2
+@test isvalid(tst1, 1)
+@test findnext(isequal('o'), L"foo", 1) == 3
+@test tst1[1] == 'a'
+@test codeunit(tst1, 1) == UInt8('a')
+@test L"foo"[1] == '$'
+@test tst1[1:2] == tst1[0x01:0x02] == tst1[[1,2]] == "an"