Draft: Implement spelled out for Māori

.github/workflows/CI.yml

@@ -15,8 +15,9 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - "1.5"   # current
-          - "nightly"   # Latest Release
+          - "1.0"       # Old version
+          - "1.6"       # Recent LTS version
+          - "nightly"   # Latest release
         os:
           - ubuntu-latest
           - macOS-latest

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Jake W. Ireland <[email protected]> and contributors
+Copyright (c) 2020–2024 Jake W. Ireland <[email protected]> and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -10,4 +10,32 @@
 
 
 ## Description
-This is a minimal package for a pure Julia implementation of converting numbers in their Arabic form to numbers in their Anglo-Saxan form.  The process of **spelling out** a number has also been referred to as **set full out**, to write out in **long hand**, and — as a great mind once suggested — to **transnumerate**.
+This is a minimal package for a pure Julia implementation of converting numbers in their Arabic form to numbers in their natural language form.  The process of **spelling out** a number has also been referred to as **set full out**, and to write out in **long hand**.  Some people to whom I look up have suggested calling this **verbal depresentation**, to **digitate**, and—one of my favourites—to **transnumerate**.
+
+## Quick Start
+```julia
+julia> using SpelledOut
+
+julia> spelled_out(1234);
+
+julia> spelled_out(1234, lang = :en);
+
+julia> spelled_out(1234, lang = :en_UK);
+```
+
+See [here](https://jakewilliami.github.io/SpelledOut.jl/dev/supported_languages/#Supported-Languages) for a list of supported languages.
+
+## Contributing
+Each new language will require a language code to use it.  This code is determined by [ISO-639-1](https://www.loc.gov/standards/iso639-2/php/langcodes-keyword.php).<sup>[[1]](https://www.wikiwand.com/en/ISO_639-1)</sup>
+
+When contributing, you should add a file and a directory: `src/<iso-639-1-lang-code>.jl`, and `src/<iso-639-1-lang-code>/`.  Within the latter, this is where you should store any language-specific dictionaries.
+
+When implementing the main function for your language (typically called `spelled_out_<iso-639-1-lang-code>`), consider implementing methods on this function for the following types:
+  - `Integer`
+  - `Rational`
+  - `Float64`
+  - `Complex`
+
+You can also add a fallback method and throw an error, but this should be caught by a `MethodError` anyway.  Now you can add to the main [`SpelledOut.jl`](src/SpelledOut.jl) function, in which you can add a branch for your language (following the trend).
+
+Finally, ensure you update the documentation for [Supported Languages](https://jakewilliami.github.io/SpelledOut.jl/dev/supported_languages/#Supported-Languages).

src/SpelledOut.jl

@@ -8,6 +8,7 @@ export spelled_out, Spelled_out, Spelled_Out, SPELLED_OUT
 include("en.jl")
 include("es.jl")
 include("pt.jl")
+include("mi.jl")
 
 """
 ```julia
@@ -53,16 +54,14 @@ function spelled_out(
     dict::Symbol = :modern
 )
 
-    if lang ∈ (:en, :en_US)
-        return spelled_out_en(number, british = false, dict = dict)
-    elseif lang ∈ (:en_UK, :en_GB, :en_NZ, :en_AU)
-        return spelled_out_en(number, british = true, dict = dict)
+    if lang ∈ (:en, :en_US, :en_UK, :en_GB, :en_NZ, :en_AU)
+        return spelled_out_en(number, british = lang ∈ (:en_UK, :en_GB, :en_NZ, :en_AU), dict = dict)
     elseif lang ∈ (:es,)
         return spelled_out_es(number; dict = dict)
-    elseif lang ∈ (:pt_BR,)
-        return spelled_out_pt(number; portugal = false, dict = dict)
-    elseif lang ∈ (:pt,)
-        return spelled_out_pt(number; portugal = true, dict = dict)
+    elseif lang ∈ (:pt, :pt_BR)
+        return spelled_out_pt(number; portugal = lang == :pt, dict = dict)
+    elseif lang ∈ (:mi,)
+        return spelled_out_mi(number)
     end
 
     throw(error("We do not support $lang yet.  Please make an issue and someone might be able to help you, or feel free to contribute."))

src/en.jl

@@ -1,23 +1,25 @@
+# Jake Ireland (@jakewilliami; October–November, 2020)
+
 # dictionaries
 include(joinpath(@__DIR__, "en", "standard_dictionary_numbers_extended.jl"))
 include(joinpath(@__DIR__, "en", "large_standard_dictionary_numbers_extended.jl"))
 include(joinpath(@__DIR__, "en", "ordinal_dictionaries.jl"))
 
 # utils
 include(joinpath(@__DIR__, "en", "utils.jl"))
-    
+
 # convert a value < 100 to English.
 function _small_convert_en!(io::IOBuffer, number::Integer)
     if number < 20
         print(io, _small_numbers[number + 1])
         return io
     end
-    
+
     m = mod(number, 10)
-    
+
     for (v, d̂) in enumerate(_tens)
         d = 20 + 10 * (v - 1)
-        
+
         if d + 10 > number
             if m ≠ 0
                 n = _small_numbers[m + 1]
@@ -28,7 +30,7 @@ function _small_convert_en!(io::IOBuffer, number::Integer)
             return io
         end
     end
-    
+
     return io
 end
 
@@ -44,7 +46,7 @@ end
 function _large_convert_en!(io::IOBuffer, number::Integer; british::Bool = false)
     divisor = div(number, 100)
     modulus = mod(number, 100)
-    
+
     if divisor > 0
         print(io, _small_numbers[divisor + 1], " hundred")
         if modulus > 0
@@ -57,11 +59,11 @@ function _large_convert_en!(io::IOBuffer, number::Integer; british::Bool = false
             print(io, "and ")
         end
     end
-    
+
     if modulus > 0
         _small_convert_en!(io, modulus)
     end
-    
+
     return io
 end
 
@@ -82,47 +84,47 @@ function _spelled_out_en!(io::IOBuffer, number_norm::Integer; british::Bool = fa
     else
         error("Unrecognized dict value: $dict")
     end
-    
+
     if number_norm < 0
         print(io, "negative ")
     end
-	
+
     if number_norm > limit - 1
         error("""SpelledOut.jl does not support numbers larger than $(limit_str * " - 1").  Sorry about that!""")
     end
-    
-    
+
+
     if number_norm < 100
         _small_convert_en!(io, number_norm)
         return io
     end
-    
+
     if number_norm < 1000
         _large_convert_en!(io, number_norm, british = british)
         return io
     end
-    
+
     number = abs(number_norm)
-    
+
     for v in 0:length(scale_numbers)
         d_idx = v
         d_number = round(big(1000)^v)
-        
+
         if d_number > number
             modulus = big(1000)^(d_idx - 1)
             l, r = divrem(number, modulus)
-            
+
             _large_convert_en!(io, l, british = british)
-            print(io, " ", scale_numbers[d_idx - 1])   
+            print(io, " ", scale_numbers[d_idx - 1])
             if r > 0
                 print(io, ", ")
                 _spelled_out_en!(io, r, british = british, dict = dict)
             end
-            
+
             return io
         end
     end
-    
+
     error("Unreachable")
 end
 
@@ -137,9 +139,9 @@ function spell_ordinal_en(number::Integer; british::Bool = false, dict::Symbol =
     word_buf = IOBuffer()
     _spelled_out_en!(word_buf, number, british = british, dict = dict)
     s = String(take!(word_buf))
-	
-	lastword = lastsplit(isspace, s)
-	redolast = lastsplit('-', lastword)
+
+    lastword = lastsplit(isspace, s)
+    redolast = lastsplit('-', lastword)
 
     if redolast != lastword
         _lastsplit = '-'
@@ -148,21 +150,21 @@ function spell_ordinal_en(number::Integer; british::Bool = false, dict::Symbol =
         _lastsplit = ' '
         word = lastword
     end
-    
+
     firstpart = firstlastsplit(_lastsplit, s)
 
     if firstpart != word
         print(word_buf, firstpart, _lastsplit)
     end
-    
+
     if haskey(irregular, word)
         print(word_buf, irregular[word])
     elseif word[end] == 'y'
         print(word_buf, word[1:end-1], ysuffix)
     else
         print(word_buf, word, suffix)
     end
-    
+
     return String(take!(word_buf))
 end
 
@@ -174,11 +176,11 @@ function decimal_convert_en(number::AbstractString; british::Bool = false, dict:
     word_buf = IOBuffer()
     _spelled_out_en!(word_buf, parse(BigInt, whole), british = british, dict = dict)
     print(word_buf, " point")
-    
+
     for i in decimal
         print(word_buf, ' ', _small_number_dictionary[i])
     end
-    
+
     return String(take!(word_buf))
 end
 
@@ -193,7 +195,7 @@ function spelled_out_en(number::AbstractFloat; british::Bool = false, dict::Symb
         # E.g., 1e10 should be parsed as an integer (as should 1.0e10)
         number = parse(BigInt, str_number)
     end
-    
+
     if isa(number, AbstractString)
         # if the number is a string then it is a decimal, which is formatted precisely
         # for correct precision with decimal places
@@ -204,7 +206,7 @@ function spelled_out_en(number::AbstractFloat; british::Bool = false, dict::Symb
     else
         throw(error("Cannot parse type $(typeof(number)).  Please make an issue."))
     end
-    
+
     # should never get here
     return nothing
 end
@@ -215,15 +217,15 @@ function spelled_out_en(number::Complex; british::Bool = false, dict::Symbol = :
 end
 
 function spelled_out_en(number::Rational; british::Bool = false, dict::Symbol = :modern)
-	_num, _den = number.num, number.den
-    
+    _num, _den = number.num, number.den
+
     # return the number itself if the denomimator is one
-	isone(_den) && return spelled_out_en(_num, british = british, dict = dict)
-    
-	word = spelled_out_en(_num, british = british, dict = dict) * " " * spell_ordinal_en(_den, british = british, dict = dict)
-    
+    isone(_den) && return spelled_out_en(_num, british = british, dict = dict)
+
+    word = spelled_out_en(_num, british = british, dict = dict) * " " * spell_ordinal_en(_den, british = british, dict = dict)
+
     # account for pluralisation
-	return isone(_num) ? word : word * "s"
+    return isone(_num) ? word : word * "s"
 end
 
 function spelled_out_en(number::AbstractIrrational; british::Bool = false, dict::Symbol = :modern)

src/en/large_standard_dictionary_numbers_extended.jl

@@ -30,6 +30,6 @@ const _large_scale_traditional_european = String[
     "sesquinquagintillion",     "sexagintilliard",                  "unsexagintillion",     "quinsexagintilliard",
     "septuagintilliard",        "quinseptuagintilliard",            "octogintilliard",      "quinoctogintilliard",
     "nonagintilliard",          "quinnonagintilliard",              "centilliard",          "quinquagintacentilliard",
-    "ducentilliard",            "quinquagintaducentilliard",        "trecentilliard",       "quinquagintatrecentilliard", 
+    "ducentilliard",            "quinquagintaducentilliard",        "trecentilliard",       "quinquagintatrecentilliard",
     "quadringentilliard",       "quinquagintaquadringentilliard",   "quingentilliard"
 ]

src/en/standard_dictionary_numbers_extended.jl

@@ -1,14 +1,14 @@
 const _small_numbers = String[
     "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
     "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
-    
+
 const _small_number_dictionary = Dict{Char, String}(
     '0' => "zero", '1' => "one", '2' => "two", '3' => "three", '4' => "four", '5' => "five", '6' => "six",
     '7' => "seven", '8' => "eight", '9' => "nine")
-    
+
 const _tens = String[
     "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
-    
+
 # The scale_numbers are US, Canada and modern British (short scale)
 const _scale_modern = String[
     "thousand",             "million",              "billion",                "trillion",               "quadrillion",
@@ -21,7 +21,7 @@ const _scale_modern = String[
     "quintrigintillion",    "sestrigintillion",     "septentrigintillion",    "octotrigintillion",      "noventrigintillion",
     "quadragintillion"
     ]
-    
+
 const _scale_traditional_british = String[
     "thousand",              "million",               "thousand million",          "billion",                   "thousand billion",
     "trillion",              "thousand trillion",     "quadrillion",               "thousand quadrillion",      "quintillion",
@@ -32,7 +32,7 @@ const _scale_traditional_british = String[
     "octodecillion",         "thousand octodecillion","novendecillion",            "thousand novendecillion",   "vigintillion",
     "thousand vigintillion"
     ]
-    
+
 const _scale_traditional_european = String[
     "thousand",              "million",               "milliard",          "billion",              "billiard",
     "trillion",              "trilliard",             "quadrillion",       "quadrilliard",         "quintillion",
@@ -44,6 +44,6 @@ const _scale_traditional_european = String[
     "octodecillion",         "octodecilliard",        "novendecillion",    "novendecilliard",      "vigintillion",
     "vigintilliard"
     ]
-    
+
 const limit = BigInt(big(10)^120)
 const limit_str = "10^120"