defmodule Cldr.Number.Format.Meta do
@moduledoc """
Describes the metadata that drives
number formatting and provides functions to
update the struct.
## Format definition
The `:format` is a keyword list that with two
elements:
* `:positive` which is a keyword list for
formatting a number >= zero
* `:negative` which is a keyword list for
formatting negative number
There are two formats because we can format in
an accounting style (that is, numbers surrounded
by `()`) or any other arbitrary style. Typically
the format for a negative number is the same as
that for a positive number with a prepended
minus sign.
## Localisation of number formatting
Number formatting is always localised to either
the currency processes locale or a locale
provided as an option to `Cldr.Number.to_string/3`.
The metadata is independent of the localisation
process. Signs (`+`/`-`), grouping (`,`), decimal markers
(`.`) and exponent signs are all localised when
the number is formatted.
## Formatting directives
The formats - positive and negative - are defined
in the metadata struct, as a keyword list of keywords
and values.
The simplest formatting list might be:
```
[format: _]`
```
The `:format` keyword indicates
that this is where the formatting number will be
substituted into the format pattern.
Another example would be for formatting a negative
number:
```
[minus: _, format: _]
```
which will format with a localised minus sign
followed by the formatted number. Note that the
keyword value for `:minus` and `:format` are
ignored.
## List of formatting keywords
The following is the full list of formatting
keywords which can be used to format a
number. A `_` in the keyword format is
used to denote `:dont_care`.
* `[format: _]` inserts the formatted number
exclusive of any sign
* `[minus: _]` inserts a localised minus
sign
* `[plus: _]` inserts a localised plus sign
* `[percent: _]` inserts a localised percent sign
* `[permille: _]` inserts a localised permille sign
* `[literal: "string"]` inserts `string` into the
format without any processing
* `[currency: 1..4]` inserts a localised currency
symbol of the given `type`. A `:currency` must be
provided as an option to `Cldr.Number.Formatter.Decimal.to_string/4`.
* `[pad: "char"]` inserts the correct number of `char`s
to pad the number format to the width specified by
`:padding_length` in the `%Meta{}` struct. The `:pad`
can be anywhere in the format list but it is most
typically inserted before or after the `:format`
keyword. The assumption is that the `char` is a single
binary character but this is not checked.
## Currency symbol formatting
Currency are localised and have four ways of being
presented. The different types are defined in the
`[currency: type]` keyword where `type` is an integer
in the range `1..4` These types will insert
into the final format:
1. The standard currency symbol like `$`,`¥` or `€`
2. The ISO currency code (like `USD` and `JPY`)
3. The localised and pluralised currency display name
like "Australian dollar" or "Australian dollars"
4. The narrow currency symbol if defined for a locale
"""
defstruct integer_digits: %{max: 0, min: 1},
fractional_digits: %{max: 0, min: 0},
significant_digits: %{max: 0, min: 0},
exponent_digits: 0,
exponent_sign: false,
scientific_rounding: 0,
grouping: %{
fraction: %{first: 0, rest: 0},
integer: %{first: 0, rest: 0}
},
round_nearest: 0,
padding_length: 0,
padding_char: " ",
multiplier: 1,
currency: nil,
format: [
positive: [format: "#"],
negative: [minus: ~c"-", format: :same_as_positive]
],
number: 0
@typedoc "Metadata type that drives how to format a number"
@type t :: %__MODULE__{
:currency => nil | Cldr.Currency.t(),
:exponent_digits => non_neg_integer(),
:exponent_sign => boolean(),
:format => [{:negative, [any(), ...]} | {:positive, [any(), ...]}, ...],
:fractional_digits => %{:max => non_neg_integer(), :min => non_neg_integer()},
:grouping => %{
:fraction => %{:first => non_neg_integer(), :rest => non_neg_integer()},
:integer => %{:first => non_neg_integer(), :rest => non_neg_integer()}
},
:integer_digits => %{:max => non_neg_integer(), :min => non_neg_integer()},
:multiplier => non_neg_integer(),
:number => non_neg_integer(),
:padding_char => String.t(),
:padding_length => non_neg_integer(),
:round_nearest => non_neg_integer(),
:scientific_rounding => non_neg_integer(),
:significant_digits => %{:max => non_neg_integer(), :min => non_neg_integer()}
}
@doc """
Returns a new number formatting metadata
struct.
"""
@spec new :: t()
def new do
%__MODULE__{}
end
@doc """
Set the minimum, and optionally maximum, integer digits to
format.
"""
@spec put_integer_digits(t(), non_neg_integer, non_neg_integer) :: t()
def put_integer_digits(%__MODULE__{} = meta, min, max \\ 0)
when is_integer(min) and is_integer(max) do
meta
|> Map.put(:integer_digits, %{min: min, max: max})
end
@doc """
Set the minimum, and optionally maximum, fractional digits to
format.
"""
@spec put_fraction_digits(t(), non_neg_integer, non_neg_integer) :: t()
def put_fraction_digits(%__MODULE__{} = meta, min, max \\ 0)
when is_integer(min) and is_integer(max) do
meta
|> Map.put(:fractional_digits, %{min: min, max: max})
end
@doc """
Set the minimum, and optionally maximum, significant digits to
format.
"""
@spec put_significant_digits(t(), non_neg_integer, non_neg_integer) :: t()
def put_significant_digits(%__MODULE__{} = meta, min, max \\ 0)
when is_integer(min) and is_integer(max) do
meta
|> Map.put(:significant_digits, %{min: min, max: max})
end
@doc """
Set the number of exponent digits to
format.
"""
@spec put_exponent_digits(t(), non_neg_integer) :: t()
def put_exponent_digits(%__MODULE__{} = meta, digits) when is_integer(digits) do
meta
|> Map.put(:exponent_digits, digits)
end
@doc """
Set whether to add the sign of the exponent to
the format.
"""
@spec put_exponent_sign(t(), boolean) :: t()
def put_exponent_sign(%__MODULE__{} = meta, flag) when is_boolean(flag) do
meta
|> Map.put(:exponent_sign, flag)
end
@doc """
Set the increment to which the number should
be rounded.
"""
@spec put_round_nearest_digits(t(), non_neg_integer) :: t()
def put_round_nearest_digits(%__MODULE__{} = meta, digits) when is_integer(digits) do
meta
|> Map.put(:round_nearest, digits)
end
@doc """
Set the number of scientific digits to which the number should
be rounded.
"""
@spec put_scientific_rounding_digits(t(), non_neg_integer) :: t()
def put_scientific_rounding_digits(%__MODULE__{} = meta, digits) when is_integer(digits) do
meta
|> Map.put(:scientific_rounding, digits)
end
@spec put_padding_length(t(), non_neg_integer) :: t()
def put_padding_length(%__MODULE__{} = meta, digits) when is_integer(digits) do
meta
|> Map.put(:padding_length, digits)
end
@doc """
Set the padding character to be used when
padding the formatted number.
"""
@spec put_padding_char(t(), String.t()) :: t()
def put_padding_char(%__MODULE__{} = meta, char) when is_binary(char) do
meta
|> Map.put(:padding_char, char)
end
@doc """
Sets the multiplier for the number.
Before formatting, the number is multiplied
by this amount. This is useful when
formatting as a percent or permille.
"""
@spec put_multiplier(t(), non_neg_integer) :: t()
def put_multiplier(%__MODULE__{} = meta, multiplier) when is_integer(multiplier) do
meta
|> Map.put(:multiplier, multiplier)
end
@doc """
Sets the number of digits in a group or
optionally the first group and subsequent
groups for the integer part of a number.
The grouping character is defined by the locale
defined for the current process or supplied
as the `:locale` option to `to_string/3`.
"""
@spec put_integer_grouping(t(), non_neg_integer, non_neg_integer) :: t()
def put_integer_grouping(%__MODULE__{} = meta, first, rest)
when is_integer(first) and is_integer(rest) do
grouping =
meta
|> Map.get(:grouping)
|> Map.put(:integer, %{first: first, rest: rest})
Map.put(meta, :grouping, grouping)
end
@spec put_integer_grouping(t(), non_neg_integer) :: t()
def put_integer_grouping(%__MODULE__{} = meta, all) when is_integer(all) do
grouping =
meta
|> Map.get(:grouping)
|> Map.put(:integer, %{first: all, rest: all})
Map.put(meta, :grouping, grouping)
end
@doc """
Sets the number of digits in a group or
optionally the first group and subsequent
groups for the fractional part of a number.
The grouping character is defined by the locale
defined for the current process or supplied
as the `:locale` option to `to_string/3`.
"""
@spec put_fraction_grouping(t(), non_neg_integer, non_neg_integer) :: t()
def put_fraction_grouping(%__MODULE__{} = meta, first, rest)
when is_integer(first) and is_integer(rest) do
grouping =
meta
|> Map.get(:grouping)
|> Map.put(:fraction, %{first: first, rest: rest})
Map.put(meta, :grouping, grouping)
end
@spec put_fraction_grouping(t(), non_neg_integer) :: t()
def put_fraction_grouping(%__MODULE__{} = meta, all) when is_integer(all) do
grouping =
meta
|> Map.get(:grouping)
|> Map.put(:fraction, %{first: all, rest: all})
Map.put(meta, :grouping, grouping)
end
@doc """
Set the metadata format for the positive
and negative number format.
Note that this is the parsed format as a simple keyword
list, not a binary representation.
Its up to each formatting engine to transform its input
into this form. See `Cldr.Number.Format.Meta` module
documentation for the available keywords.
"""
@spec put_format(t(), Keyword.t(), Keyword.t()) :: t()
def put_format(%__MODULE__{} = meta, positive_format, negative_format) do
meta
|> Map.put(:format, positive: positive_format, negative: negative_format)
end
@spec put_format(t(), Keyword.t()) :: t()
def put_format(%__MODULE__{} = meta, positive_format) do
put_format(meta, positive_format, minus: ~c"-", format: :same_as_positive)
end
end
