Add JSON3.tostring for Real number overloads when writing (#236)

* Add `JSON3.tostring` for Real number overloads when writing

This is the best idea I can come up with to address
#232. First a summary of the problem,
  * We allow custom number types to overload `StructTypes.numbertype` that we
    convert to before writing JSON
  * However, we only provide JSON writing routines for `Integer` and `AbstractFloat`
  * So a number like `3//2` (`Rational`) or `π` (`Irrational`) which are both `<: Real`,
    but not `Integer` or `AbstractFloat` we get the stack overlfow behavior reported above

The proposal here then is we first check if a `Real` has overloaded `StructTypes.numbertype`
and _if not_, we'll use a new `JSON3.tostring` method, which by default converts the custom
number to `Float64` and then calls `Base.string(x)`. This method allows custom number types,
like FixedPointDecimal, to overload `JSON3.tostring` to provide an appropriate string representation
for their type.

* add tostring to docs

Author: quinnj

docs/src/index.md

@@ -182,6 +182,7 @@ JSON3.AlignmentContext
 JSON3.Object
 JSON3.Array
 Base.copy
+JSON3.tostring
 ```
 
 ### In Relation to Other JSON Packages

src/write.jl

@@ -210,8 +210,37 @@ function write(::NumberType, buf, pos, len, y::Integer; kw...)
     return buf, pos + n, len
 end
 
-write(::NumberType, buf, pos, len, x::T; kw...) where {T} =
-    write(NumberType(), buf, pos, len, StructTypes.construct(StructTypes.numbertype(T), x); kw...)
+# default fallback for non-Integer/non-AbstractFloat numbers
+# conver to Float64 and write the string representation
+"""
+    JSON3.tostring(x::Real) -> String
+
+For some number types that are `<: Real`, but not `<: Integer` or `<: AbstractFloat`,
+`tostring` provides an overload to convert `x` to an appropriate string representation
+which will be used for the JSON numeric representation. By default, `x` is converted
+to a `Float64` and then to a `String`.
+"""
+tostring(x::Real) = Base.string(convert(Float64, x))
+
+function write(::NumberType, buf, pos, len, x::T; kw...) where {T}
+    NT = StructTypes.numbertype(T)
+    if NT === T
+        # this means T hasn't overloaded numbertype
+        # and we can't StructTypes.construct since we'll just stack overflow
+        # so we call last-chance tostring that can be overloaded
+        bytes = codeunits(tostring(x))
+        sz = sizeof(bytes)
+        @check sz
+        for i = 1:sz
+            @inbounds @writechar bytes[i]
+        end
+
+        return buf, pos, len
+    else
+        write(NumberType(), buf, pos, len, StructTypes.construct(NT, x); kw...)
+    end
+end
+
 function write(::NumberType, buf, pos, len, x::AbstractFloat; allow_inf::Bool=false, kw...)
     isfinite(x) || allow_inf || error("$x not allowed to be written in JSON spec")
     bytes = codeunits(Base.string(x))

test/runtests.jl

@@ -1062,4 +1062,8 @@ s1_json = String(take!(iob))
 s2 = JSON3.read(s1_json, Struct1)
 @test s1.iarr == s2.iarr
 
+# https://github.com/quinnj/JSON3.jl/issues/232
+@test JSON3.write(3//2) == "1.5"
+@test JSON3.write(π) == "3.141592653589793"
+1
 end # @testset "JSON3"