Add support for _ and , separators for Python formats (#68)

* Support _ as well as comma for pyfmt

* Implement and cleanup support for , and _ separators for Python formats

* Add more tests for Python separators

Author: ScottPJones

README.md

@@ -34,7 +34,16 @@ This package offers Python-style general formatting and c-style numerical format
 
 ## Getting Started
 
-This package is pure Julia.  It is now registered, so it can be added simply with `Pkg.add("Format")`.
+This package is pure Julia. Setting up this package is like setting up other Julia packages:
+
+```julia
+Pkg.add("Format")
+```
+or
+```julia
+]add Format
+```
+
 It is forked off of [Formatting.jl](https://github.com/JuliaIO/Formatting.jl), and I try to keep the oldmaster branch up to date with the master branch of that, and cherry pick or port all necessary changes to `Format`).
 
 To start using the package, you can simply write
@@ -43,7 +52,7 @@ To start using the package, you can simply write
 using Format
 ```
 
-This package depends on Julia of version 0.6 or above, and. The package is MIT-licensed.
+This package depends on Julia of version 1.4 or above, and. The package is MIT-licensed.
 
 
 ## Python-style Types and Functions
@@ -133,10 +142,6 @@ One can use ``pyfmt`` to format a single value into a string, or ``format`` to f
 
 At this point, this package implements a subset of Python's formatting language (with slight modification). Here is a summary of the differences:
 
-- ``g`` and ``G`` for floating point formatting have not been supported yet. Please use ``f``, ``e``, or ``E`` instead.
-
-- The package currently provides default alignment, left alignment ``<`` and right alignment ``>``. Other form of alignment such as centered alignment ``^`` has not been supported yet.
-
 - In terms of argument specification, it supports natural ordering (e.g. ``{} + {}``), explicit position (e.g. ``{1} + {2}``). It hasn't supported named arguments or fields extraction yet. Note that mixing these two modes is not allowed (e.g. ``{1} + {}``).
 
 - The package provides support for filtering (for explicitly positioned arguments), such as ``{1|>lowercase}`` by allowing one to embed the ``|>`` operator, which the Python counter part does not support.
@@ -171,19 +176,12 @@ fmtrfunc = generate_formatter( fmt ) # usage 2. This bypass repeated lookup of c
 s = fmtrfunc( 3.14159 )
 
 s = format( 3.14159, precision=3 ) # usage 3. Most flexible, with some non-printf options. Least performant.
-```
-### Speed
-
-`cfmt`: Speed penalty is about 20% for floating point and 30% for integers.
-
-If the formatter is stored and used instead (see the example using `generate_formatter` above),
-the speed penalty reduces to 10% for floating point and 15% for integers.
 
 ### Commas
 
-This package also supplements the lack of thousand separator e.g. `"%'d"`, `"%'f"`, `"%'s"`.
+This package also supplements the lack of thousand separator e.g. `"%'d"`, `"%'f"`, `"%'g"`.
 
-Note: `"%'s"` behavior is that for small enough floating point (but not too small),
+Note: `"%'g"` behavior is that for small enough floating point (but not too small),
 thousand separator would be used. If the number needs to be represented by `"%e"`, no
 separator is used.
 
@@ -198,7 +196,7 @@ s = format( 1234, commas=true ) # 1,234
 s = format( -1234, commas=true, parens=true ) # (1,234)
 ```
 
-The keyword arguments are (Bold keywards are not printf standard)
+The keyword arguments are (Bold keywords are not printf standard)
 
 * width. Integer. Try to fit the output into this many characters. May not be successful.
    Sacrifice space first, then commas.

src/Format.jl

@@ -121,23 +121,16 @@ using Format
 fmt = "%10.3f"
 s = cfmt( fmt, 3.14159 ) # usage 1. Quite performant. Easiest to switch to.
 
-fmtrfunc = generate_formatter( fmt ) # usage 2. This bypass repeated lookup of cached function. Most performant.
+fmtrfunc = generate_formatter( fmt ) # usage 2. This bypasses repeated lookup of cached function. Most performant.
 s = fmtrfunc( 3.14159 )
 
 s = format( 3.14159, precision=3 ) # usage 3. Most flexible, with some non-printf options. Least performant.
 ```
-### Speed
-
-`cfmt`: Speed penalty is about 20% for floating point and 30% for integers.
-
-If the formatter is stored and used instead (see the example using `generate_formatter` above),
-the speed penalty reduces to 10% for floating point and 15% for integers.
-
 ### Commas
 
-This package also supplements the lack of thousand separator e.g. `"%'d"`, `"%'f"`, `"%'s"`.
+This package also supplements the lack of thousand separator e.g. `"%'d"`, `"%'f"`, `"%'g"`.
 
-Note: `"%'s"` behavior is that for small enough floating point (but not too small),
+Note: `"%'g"` behavior is that for small enough floating point (but not too small),
 thousand separator would be used. If the number needs to be represented by `"%e"`, no
 separator is used.
 

src/cformat.jl

@@ -10,9 +10,9 @@ function _get_formatter(fmt)
     _formatters[fmt] = FmtSpec(fmt)
 end
 
-_cfmt_comma(fspec::FmtSpec, x) = addcommasreal(_cfmt(fspec, x))
-_cfmt_comma(fspec::FmtSpec{FmtStr}, x::Rational) =  addcommasrat(_cfmt(fspec, x))
-_cfmt_comma(fspec::FmtSpec{<:FmtInts}, x) = checkcommas(_cfmt(fspec, x))
+_cfmt_comma(fspec::FmtSpec, x) = addcommasreal(_cfmt(fspec, x), Char(fspec.tsep))
+_cfmt_comma(fspec::FmtSpec{FmtStr}, x::Rational) =  addcommasrat(_cfmt(fspec, x), Char(fspec.tsep))
+_cfmt_comma(fspec::FmtSpec{<:FmtInts}, x) = checkcommas(_cfmt(fspec, x), Char(fspec.tsep))
 
 function _cfmt(fspec::FmtSpec, x)
     sv = Base.StringVector(23) # Trust that lower level code will expand if necessary
@@ -29,29 +29,29 @@ function generate_formatter(fmt::ASCIIStr)
     fspec.tsep == 0 ? x -> _cfmt(fspec, x) : x -> _cfmt_comma(fspec, x)
 end
 
-function addcommasreal(s)
+function addcommasreal(s, sep)
     len = length(s)
     dpos = findfirst( isequal('.'), s )
-    dpos !== nothing && return addcommas(s, len, dpos-1)
+    dpos !== nothing && return addcommas(s, len, dpos-1, sep)
     # find the rightmost digit
     for i in len:-1:1
-        isdigit( s[i] ) && return addcommas(s, len, i)
+        isdigit( s[i] ) && return addcommas(s, len, i, sep)
     end
     s
 end
 
 # commas are added to only the numerator
-addcommasrat(s) = addcommas(s, length(s), findfirst( isequal('/'), s )-1)
+addcommasrat(s, sep) = addcommas(s, length(s), findfirst( isequal('/'), s )-1, sep)
 
-function checkcommas(s)
+function checkcommas(s, sep)
     len = length(s)
     for i in len:-1:1
-        isdigit( s[i] ) && return addcommas(s, len, i)
+        isdigit( s[i] ) && return addcommas(s, len, i, sep)
     end
     s
 end
 
-function addcommas(s::T, len, lst) where {T<:AbstractString}
+function addcommas(s::T, len, lst, sep) where {T<:AbstractString}
     lst < 4 && return s
     beg = 1
     while beg < len
@@ -69,12 +69,12 @@ function addcommas(s::T, len, lst) where {T<:AbstractString}
     pos = beg - 1
     for i = beg:lst-3
         sv[pos += 1] = s[i]
-        (cnt -= 1) == 0 && (cnt = 3; sv[pos += 1] = ',')
+        (cnt -= 1) == 0 && (cnt = 3; sv[pos += 1] = sep)
     end
     for i = lst-2:len; sv[i+commas] = s[i]; end
     T(sv)
 end
-addcommas(s) = (l = length(s); addcommas(s, l, l))
+addcommas(s, sep) = (l = length(s); addcommas(s, l, l, sep))
 
 function generate_format_string(;
                                 width::Int=-1,
@@ -108,6 +108,37 @@ function generate_format_string(;
     String(append!(s, _codeunits(conversion)))
 end
 
+"""
+Format a value, using the following keyword arguments to control formatting
+(Bold keywords are not printf standard):
+
+* width. Integer. Try to fit the output into this many characters. May not be successful.
+   Sacrifice space first, then commas.
+* precision. Integer. How many decimal places.
+* leftjustified. Boolean
+* zeropadding. Boolean
+* commas. Boolean. Thousands-group separator.
+* signed. Boolean. Always show +/- sign?
+* positivespace. Boolean. Prepend an extra space for positive numbers? (so they align nicely with negative numbers)
+* **parens**. Boolean. Use parenthesis instead of "-". e.g. `(1.01)` instead of `-1.01`. Useful in finance. Note that
+  you cannot use `signed` and `parens` option at the same time.
+* **stripzeros**. Boolean. Strip trailing '0' to the right of the decimal (and to the left of 'e', if any ).
+   * It may strip the decimal point itself if all trailing places are zeros.
+   * This is true by default if precision is not given, and vice versa.
+* alternative. Boolean. See `#` alternative form explanation in standard printf documentation
+* conversion. length=1 string. Default is type dependent. It can be one of `aAeEfFoxX`. See standard
+  printf documentation.
+* **mixedfraction**. Boolean. If the number is rational, format it in mixed fraction e.g. `1_1/2` instead of `3/2`
+* **mixedfractionsep**. Default `_`
+* **fractionsep**. Default `/`
+* **fractionwidth**. Integer. Try to pad zeros to the numerator until the fractional part has this width
+* **tryden**. Integer. Try to use this denominator instead of a smaller one. No-op if it'd lose precision.
+* **suffix**. String. This strings will be appended to the output. Useful for units/%
+* **autoscale**. Symbol, default `:none`. It could be `:metric`, `:binary`, or `:finance`.
+    * `:metric` implements common SI symbols for large and small numbers e.g. `M`, `k`, `μ`, `n`
+    * `:binary` implements common ISQ symbols for large numbers e.g. `Ti`, `Gi`, `Mi`, `Ki`
+    * `:finance` implements common finance/news symbols for large numbers e.g. `b` (billion), `m` (millions)
+"""
 function format( x::T;
                  width::Int=-1,
                  precision::Int= -1,

src/fmt.jl

@@ -141,17 +141,10 @@ end
 function _optional_commas(x::Real, s::AbstractString, fspec::FormatSpec)
     prevwidth = length(s)
     dpos = findfirst( isequal('.'), s)
-    s = addcommas(s, prevwidth, dpos === nothing ? prevwidth : dpos - 1)
-
+    ns = addcommas(s, prevwidth, dpos === nothing ? prevwidth : dpos - 1, fspec.sep)
     # check for excess width from commas
     w = length(s)
-    if fspec.width > 0 && w > fspec.width && w > prevwidth
-        # we may have made the string too wide with those commas... gotta fix it
-        # left or right alignment ('<' is left)
-        # TODO: handle center alignment
-        s = fspec.align == '<' ? rpad(strip(s), fspec.width) : lpad(strip(s), fspec.width)
-    end
-    s
+    (fspec.width > 0 && w > fspec.width && w > prevwidth) ? s : ns
 end
 _optional_commas(x, s::AbstractString, fspec::FormatSpec) = s
 
@@ -198,10 +191,7 @@ function fmt end
 function fmt(x; kwargs...)
     fspec = fmt_default(x)
     isempty(kwargs) || (fspec = FormatSpec(fspec; kwargs...))
-    s = pyfmt(fspec, x)
-    # TODO: allow other thousands separators besides comma
-    # add the commas now... I was confused as to when this is done currently
-    fspec.tsep ? _optional_commas(x, s, fspec) : s
+    pyfmt(fspec, x)
 end
 
 # some helper method calls, which just convert to kwargs