mirror of
https://github.com/miniflux/v2.git
synced 2024-08-30 16:17:20 +02:00
178 lines
4.7 KiB
Go
178 lines
4.7 KiB
Go
|
// Copyright 2017 The Go Authors. All rights reserved.
|
||
|
// Use of this source code is governed by a BSD-style
|
||
|
// license that can be found in the LICENSE file.
|
||
|
|
||
|
package number
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
|
||
|
"golang.org/x/text/internal/number"
|
||
|
"golang.org/x/text/language"
|
||
|
)
|
||
|
|
||
|
// An Option configures a Formatter.
|
||
|
type Option option
|
||
|
|
||
|
type option func(tag language.Tag, f *number.Formatter)
|
||
|
|
||
|
// TODO: SpellOut requires support of the ICU RBNF format.
|
||
|
// func SpellOut() Option
|
||
|
|
||
|
// NoSeparator causes a number to be displayed without grouping separators.
|
||
|
func NoSeparator() Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
f.GroupingSize = [2]uint8{}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// MaxIntegerDigits limits the number of integer digits, eliminating the
|
||
|
// most significant digits.
|
||
|
func MaxIntegerDigits(max int) Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
if max >= 1<<8 {
|
||
|
max = (1 << 8) - 1
|
||
|
}
|
||
|
f.MaxIntegerDigits = uint8(max)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// MinIntegerDigits specifies the minimum number of integer digits, adding
|
||
|
// leading zeros when needed.
|
||
|
func MinIntegerDigits(min int) Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
if min >= 1<<8 {
|
||
|
min = (1 << 8) - 1
|
||
|
}
|
||
|
f.MinIntegerDigits = uint8(min)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// MaxFractionDigits specifies the maximum number of fractional digits.
|
||
|
func MaxFractionDigits(max int) Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
if max >= 1<<15 {
|
||
|
max = (1 << 15) - 1
|
||
|
}
|
||
|
f.MaxFractionDigits = int16(max)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// MinFractionDigits specifies the minimum number of fractional digits.
|
||
|
func MinFractionDigits(min int) Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
if min >= 1<<8 {
|
||
|
min = (1 << 8) - 1
|
||
|
}
|
||
|
f.MinFractionDigits = uint8(min)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Precision sets the maximum number of significant digits. A negative value
|
||
|
// means exact.
|
||
|
func Precision(prec int) Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
f.SetPrecision(prec)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Scale simultaneously sets MinFractionDigits and MaxFractionDigits to the
|
||
|
// given value.
|
||
|
func Scale(decimals int) Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
f.SetScale(decimals)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// IncrementString sets the incremental value to which numbers should be
|
||
|
// rounded. For instance: Increment("0.05") will cause 1.44 to round to 1.45.
|
||
|
// IncrementString also sets scale to the scale of the increment.
|
||
|
func IncrementString(decimal string) Option {
|
||
|
increment := 0
|
||
|
scale := 0
|
||
|
d := decimal
|
||
|
p := 0
|
||
|
for ; p < len(d) && '0' <= d[p] && d[p] <= '9'; p++ {
|
||
|
increment *= 10
|
||
|
increment += int(d[p]) - '0'
|
||
|
}
|
||
|
if p < len(d) && d[p] == '.' {
|
||
|
for p++; p < len(d) && '0' <= d[p] && d[p] <= '9'; p++ {
|
||
|
increment *= 10
|
||
|
increment += int(d[p]) - '0'
|
||
|
scale++
|
||
|
}
|
||
|
}
|
||
|
if p < len(d) {
|
||
|
increment = 0
|
||
|
scale = 0
|
||
|
}
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
f.Increment = uint32(increment)
|
||
|
f.IncrementScale = uint8(scale)
|
||
|
f.SetScale(scale)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func noop(language.Tag, *number.Formatter) {}
|
||
|
|
||
|
// PatternOverrides allows users to specify alternative patterns for specific
|
||
|
// languages. The Pattern will be overridden for all languages in a subgroup as
|
||
|
// well. The function will panic for invalid input. It is best to create this
|
||
|
// option at startup time.
|
||
|
// PatternOverrides must be the first Option passed to a formatter.
|
||
|
func PatternOverrides(patterns map[string]string) Option {
|
||
|
// TODO: make it so that it does not have to be the first option.
|
||
|
// TODO: use -x-nochild to indicate it does not override child tags.
|
||
|
m := map[language.Tag]*number.Pattern{}
|
||
|
for k, v := range patterns {
|
||
|
tag := language.MustParse(k)
|
||
|
p, err := number.ParsePattern(v)
|
||
|
if err != nil {
|
||
|
panic(fmt.Errorf("number: PatternOverrides: %v", err))
|
||
|
}
|
||
|
m[tag] = p
|
||
|
}
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
// TODO: Use language grouping relation instead of parent relation.
|
||
|
// TODO: Should parent implement the grouping relation?
|
||
|
for lang := t; ; lang = t.Parent() {
|
||
|
if p, ok := m[lang]; ok {
|
||
|
f.Pattern = *p
|
||
|
break
|
||
|
}
|
||
|
if lang == language.Und {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// FormatWidth sets the total format width.
|
||
|
func FormatWidth(n int) Option {
|
||
|
if n <= 0 {
|
||
|
return noop
|
||
|
}
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
f.FormatWidth = uint16(n)
|
||
|
if f.PadRune == 0 {
|
||
|
f.PadRune = ' '
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Pad sets the rune to be used for filling up to the format width.
|
||
|
func Pad(r rune) Option {
|
||
|
return func(t language.Tag, f *number.Formatter) {
|
||
|
f.PadRune = r
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// TODO:
|
||
|
// - FormatPosition (using type aliasing?)
|
||
|
// - Multiplier: find a better way to represent and figure out what to do
|
||
|
// with clashes with percent/permille.
|
||
|
// - NumberingSystem(nu string): not accessable in number.Info now. Also, should
|
||
|
// this be keyed by language or generic?
|
||
|
// - SymbolOverrides(symbols map[string]map[number.SymbolType]string) Option
|