tater 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6106cd4e2b4936a681033a8d27c663cde05b412c014d155d79363b36370a07b7
-  data.tar.gz: cc2ad7ed82fce6f3718a3f56d5475d750b006708c16882b82197c2f54c9dec32
+  metadata.gz: c34d7058c3566313243c4ccb7b99d967c60bf2e00e091d1fbb66dfbd257e853f
+  data.tar.gz: 0a5c1d4df6a34b9953086af0459af4c72cb8d9faf674d3216e1eb9e00aa0e82f
 SHA512:
-  metadata.gz: 4cbf5271ab90d0b5d941dc3a338363c61f0a82916df5da691f2be08cf31ca8b77afa3099f9eb83e8b28c08b13d36e46eb3bb2d63129d44f5e4d3e267dea9da43
-  data.tar.gz: f5c6d9b1d95f94bb9780d351d5d6ecfb30e9d66706559854cfa77dfa303cee9ab9b67fb325ea78a7b9a0092a6a439d0163221e8e06ae650da163391fb88c361e
+  metadata.gz: ac657b28f3e3421def12e3d0b50bcd895c5d1a1b23de7c97da6bf0e20bc5e0a51e20abf7394ec9e99b2137e9b2261392213f0dc85d2d3b0c598c4e73184d8857
+  data.tar.gz: 4b5b32cf7b23a66afcde0a73f129a76d791f62a8efa45a7223204d9e017328796cf528ad8884a2c25a568ea47d3047fff57c4973741aaae20e1e7574350a9068

data/{README.md → README.org}

@@ -1,42 +1,39 @@
-# Tater 
+* Tater
 
-[![Gem Version](https://badge.fury.io/rb/tater.svg)](https://badge.fury.io/rb/tater)
-[![Build Status](https://travis-ci.com/evanleck/tater.svg?branch=main)](https://travis-ci.com/evanleck/tater)
+[[https://badge.fury.io/rb/tater][https://badge.fury.io/rb/tater.svg]]
 
 Tater is an internationalization (i18n) and localization (l10n) library designed
 for simplicity. It doesn't do everything that other libraries do, but that's by
 design.
 
-Under the hood, Tater uses a Hash to store the messages, the `dig` method for
-lookups, `strftime` for date and time localizations, and `format` for
+Under the hood, Tater uses a Hash to store the messages, the =dig= method for
+lookups, =strftime= for date and time localizations, and =format= for
 interpolation. That's probably 90% of what Tater does.
 
-
-## Installation
+** Installation
 
 Tater requires Ruby 2.5 or higher. To install Tater, add this line to your
 application's Gemfile (or gems.rb):
 
-```ruby
+#+begin_src ruby
 gem 'tater'
-```
+#+end_src
 
 And then execute:
 
-```sh
+#+begin_src sh
 bundle
-```
+#+end_src
 
 Or install it yourself by running:
 
-```sh
+#+begin_src sh
 gem install tater
-```
-
+#+end_src
 
-## Usage
+** Usage
 
-```ruby
+#+begin_src ruby
 require 'tater'
 
 messages = {
@@ -59,59 +56,56 @@ i18n.translate('some.key') # => 'This here string!'
 
 # Interpolation:
 i18n.translate('interpolated', you: 'world') # => 'Hello world!'
-```
+#+end_src
 
-
-## Array localization
+** Array localization
 
 Given an array, Tater will do it's best to join the elements of the array into a
 sentence based on how many elements there are.
 
-```yaml
+#+begin_example
 en:
   array:
     last_word_connector: ", and "
     two_words_connector: " and "
     words_connector: ", "
-```
+#+end_example
 
-```ruby
+#+begin_src ruby
 i18n.localize(%w[tacos enchiladas burritos]) # => "tacos, enchiladas, and burritos"
-```
-
+#+end_src
 
-## Numeric localization
+** Numeric localization
 
-Numeric localization (`Numeric`, `Integer`, `Float`, and `BigDecimal`) require
+Numeric localization (=Numeric=, =Integer=, =Float=, and =BigDecimal=) require
 filling in a separator and delimiter. For example:
 
-```yaml
+#+begin_example
 en:
   numeric:
     delimiter: ','
     separator: '.'
-```
+#+end_example
 
 With that, you can do things like this:
 
-```ruby
+#+begin_src ruby
 i18n.localize(1000.2) # => "1,000.20"
-```
+#+end_src
 
 The separator and delimiter can also be passed in per-call:
 
-```ruby
+#+begin_src ruby
 i18n.localize(1000.2, delimiter: '_', separator: '+') # => "1_000+20"
-```
+#+end_src
 
+** Date and time localization
 
-## Date and time localization
-
-Date and time localization (`Date`, `Time`, and `DateTime`) require filling in
+Date and time localization (=Date=, =Time=, and =DateTime=) require filling in
 all of the needed names and abbreviations for days and months. Here's the
 example for French, which is used in the tests.
 
-```yaml
+#+begin_example
 fr:
   time:
     am: 'am'
@@ -174,28 +168,27 @@ fr:
       - oct.
       - nov.
       - déc.
-```
+#+end_example
 
-The statically defined keys for dates are `days`, `abbreviated_days`, `months`,
-and `abbreviated_months`. Only `am` and `pm` are needed for times and only if
-you plan on using the `%p` or `%P` format strings.
+The statically defined keys for dates are =days=, =abbreviated_days=, =months=,
+and =abbreviated_months=. Only =am= and =pm= are needed for times and only if
+you plan on using the =%p= or =%P= format strings.
 
 With all of that, you can do something like:
 
-```ruby
+#+begin_src ruby
 i18n.localize(Date.new(1970, 1, 1), format: '%A') # => 'jeudi'
 
 # Or, using a key defined in "formats":
 i18n.localize(Date.new(1970, 1, 1), format: 'day') # => 'jeudi'
-```
-
+#+end_src
 
-## Cascading lookups
+** Cascading lookups
 
-Lookups can be cascaded, i.e. pieces of the scope of the can be lopped off
+Lookups can be cascaded, i.e. pieces of the scope of the can be lopped off
 incrementally.
 
-```ruby
+#+begin_src ruby
 messages = {
   'en' => {
     'login' => {
@@ -214,42 +207,40 @@ i18n.translate('login.special.title') # => 'Special Login'
 i18n.translate('login.special.description') # => 'Tater lookup failed'
 
 i18n.translate('login.special.description', cascade: true) # => 'Normal description.'
-```
+#+end_src
 
 With cascade, the final key stays the same, but pieces of the scope get lopped
 off. In this case, lookups will be tried in this order:
 
-1. `'login.special.description'`
-2. `'login.description'`
+1. ='login.special.description'=
+2. ='login.description'=
 
 This can be useful when you want to override some messages but don't want to
 have to copy all of the other, non-overwritten messages.
 
 Cascading can also be enabled by default when initializing an instance of Tater.
 
-```ruby
+#+begin_src ruby
 Tater.new(cascade: true)
-```
+#+end_src
 
 Cascading is off by default.
 
-
-## Defaults
+** Defaults
 
 If you'd like to default to another value in case of a missed lookup, you can
-provide the `:default` option to `#translate`.
+provide the =:default= option to =#translate=.
 
-```ruby
+#+begin_src ruby
 Tater.new.translate('nope', default: 'Yep!') # => 'Yep!'
-```
+#+end_src
 
-
-## Procs and messages in Ruby
+** Procs and messages in Ruby
 
 Ruby files can be used to store messages in addition to YAML, so long as the
-Ruby file returns a `Hash` when evalled.
+Ruby file returns a =Hash= when evalled.
 
-```ruby
+#+begin_src ruby
 {
   'en' => {
     ruby: proc do |key, options = {}|
@@ -257,16 +248,15 @@ Ruby file returns a `Hash` when evalled.
     end
   }
 }
-```
-
+#+end_src
 
-## Multiple locales
+** Multiple locales
 
 If you would like to check multiple locales and pull the first matching one out,
-you can pass the `:locales` option to initialization or the `translate` method
+you can pass the =:locales= option to initialization or the =translate= method
 with an array of top-level locale keys.
 
-```ruby
+#+begin_src ruby
 messages = {
   'en' => {
     'title' => 'Login',
@@ -285,31 +275,23 @@ i18n.translate('description', locales: %w[fr en]) # => 'English description.'
 i18n = Tater.new(messages: messages, locales: %w[fr en])
 i18n.translate('title') # => 'la connexion'
 i18n.translate('description') # => 'English description.'
-```
+#+end_src
 
 Locales will be tried in order and whichever one matches first will be returned.
 
+** Limitations
 
-## Limitations
-
-- It is not "pluggable", it does what it does and that's it.
+- It is not pluggable, it does what it does and that's it.
 - It doesn't handle pluralization yet, though it may in the future.
-- It doesn't cache anything, that's up to you.
-
-
-## Why?
-
-Because [Ruby I18n][rubyi18n] is amazing and I wanted to try to create a minimum
-viable implementation of the bits of I18n that I use 90% of the time. Tater is a
-single file that handles the basics of lookup and interpolation.
 
+** Why?
 
-## Trivia
+Because [[https://github.com/ruby-i18n/i18n][Ruby I18n]] is amazing and I wanted to try to create a minimum viable
+implementation of the bits of I18n that I use 90% of the time. Tater is a single
+file that handles the basics of lookup and interpolation.
 
-I was orininally going to call this library "Translator" but with a
-[numeronym][numeronym] like I18n: "t8r". I looked at it for a while but I read
-it as "tater" instead of "tee-eight-arr" so I figured I'd just name it Tater.
-Tater the translator.
+** Trivia
 
-[numeronym]: https://en.wikipedia.org/wiki/Numeronym
-[rubyi18n]: https://github.com/ruby-i18n/i18n
+I was orininally going to call this library "Translator" but with a [[https://en.wikipedia.org/wiki/Numeronym][numeronym]]
+like I18n: "t8r".  I looked at it for a while but I read it as "tater" instead
+of "tee-eight-arr" so I figured I'd just name it Tater. Tater the translator.

data/lib/tater.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 require 'bigdecimal'
+require 'date'
+require 'time'
 require 'yaml'
+require 'tater/utils'
 
 # Tater is a internationalization (i18n) and localization (l10n) library
 # designed for speed and simplicity.
@@ -8,83 +11,6 @@ class Tater
   class MissingLocalizationFormat < ArgumentError; end
   class UnLocalizableObject < ArgumentError; end
 
-  module Utils # :nodoc:
-    # Merge all the way down.
-    #
-    # @param to [Hash]
-    #   The target Hash to merge into.
-    # @param from [Hash]
-    #   The Hash to copy values from.
-    # @return [Hash]
-    def self.deep_merge(to, from)
-      to.merge(from) do |_key, left, right|
-        if left.is_a?(Hash) && right.is_a?(Hash)
-          Utils.deep_merge(left, right)
-        else
-          right
-        end
-      end
-    end
-
-    # Transform keys all the way down.
-    #
-    # @param hash [Hash]
-    #   The Hash to stringify keys for.
-    # @return [Hash]
-    def self.deep_stringify_keys(hash)
-      hash.transform_keys(&:to_s).transform_values do |value|
-        if value.is_a?(Hash)
-          Utils.deep_stringify_keys(value)
-        else
-          value
-        end
-      end
-    end
-
-    # Freeze all the way down.
-    #
-    # @param hash [Hash]
-    # @return [Hash]
-    def self.deep_freeze(hash)
-      hash.transform_keys(&:freeze).transform_values do |value|
-        if value.is_a?(Hash)
-          Utils.deep_freeze(value)
-        else
-          value.freeze
-        end
-      end.freeze
-    end
-
-    # Try to interpolate these things, if one of them is a string.
-    #
-    # @param string [String]
-    #   The target string to interpolate into.
-    # @param options [Hash]
-    #   The values to interpolate into the target string.
-    #
-    # @return [String]
-    def self.interpolate(string, options = HASH)
-      return string unless string.is_a?(String)
-      return string if options.empty?
-
-      format(string, options)
-    end
-
-    # Convert a Numeric to a string, particularly formatting BigDecimals to a
-    # Float-like string representation.
-    #
-    # @param numeric [Numeric]
-    #
-    # @return [String]
-    def self.string_from_numeric(numeric)
-      if numeric.is_a?(BigDecimal)
-        numeric.to_s('F')
-      else
-        numeric.to_s
-      end
-    end
-  end
-
   DEFAULT = 'default'
   DELIMITING_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/.freeze
   HASH = {}.freeze
@@ -106,7 +32,6 @@ class Tater
   # @param path [String]
   #   A path to search for YAML or Ruby files to load messages from.
   def initialize(cascade: false, locale: nil, messages: nil, path: nil)
-    @cache = {}
     @cascade = cascade
     @locale = locale
     @messages = {}
@@ -152,7 +77,7 @@ class Tater
       end
 
       Dir.glob(File.join(path, '**', '*.rb')).each do |file|
-        @messages = Utils.deep_merge(@messages, Utils.deep_stringify_keys(eval(IO.read(file), binding, file))) # rubocop:disable Security/Eval
+        @messages = Utils.deep_merge(@messages, Utils.deep_stringify_keys(eval(File.read(file), binding, file))) # rubocop:disable Security/Eval
       end
     end
 
@@ -164,8 +89,10 @@ class Tater
 
     # Not only does this clear our cache but it establishes the basic structure
     # that we rely on in other methods.
+    @cache = {}
+
     @messages.each_key do |key|
-      @cache[key] = { true => {}, false => {} }
+      @cache[key] = { false => {}, true => {} }
     end
   end
 
@@ -189,9 +116,9 @@ class Tater
   # @option options [String] :locale
   #   The locale to use in lieu of the current default.
   # @option options [String] :delimiter
-  #   The delimiter to use when localizing numberic values.
+  #   The delimiter to use when localizing numeric values.
   # @option options [String] :separator
-  #   The separator to use when localizing numberic values.
+  #   The separator to use when localizing numeric values.
   # @option options [String] :two_words_connector
   #   The string used to join two array elements together e.g. " and ".
   # @option options [String] :words_connector
@@ -207,105 +134,57 @@ class Tater
     when String
       object
     when Numeric
-      delimiter = options[:delimiter] || lookup('numeric.delimiter', locale: options[:locale])
-      separator = options[:separator] || lookup('numeric.separator', locale: options[:locale])
-      precision = options[:precision] || 2
-
-      raise(MissingLocalizationFormat, "Numeric localization delimiter ('numeric.delimiter') missing or not passed as option :delimiter") unless delimiter
-      raise(MissingLocalizationFormat, "Numeric localization separator ('numeric.separator') missing or not passed as option :separator") unless separator
-
-      # Heavily cribbed from Rails.
-      integer, fraction = Utils.string_from_numeric(object).split('.')
-      integer.gsub!(DELIMITING_REGEX) do |number|
-        "#{ number }#{ delimiter }"
-      end
-
-      if precision.zero?
-        integer
-      else
-        [integer, fraction&.ljust(precision, '0')&.slice(0, precision)].compact.join(separator)
-      end
+      localize_numeric(object, options)
     when Date, Time, DateTime
-      format = lookup("#{ object.class.to_s.downcase }.formats.#{ options[:format] || DEFAULT }", locale: options[:locale]) || options[:format] || DEFAULT
-
-      # Heavily cribbed from I18n, many thanks to the people who sorted this out
-      # before I worked on this library.
-      format = format.gsub(SUBSTITUTION_REGEX) do |match|
-        case match
-        when '%a'  then lookup('date.abbreviated_days', locale: options[:locale])[object.wday]
-        when '%^a' then lookup('date.abbreviated_days', locale: options[:locale])[object.wday].upcase
-        when '%A'  then lookup('date.days', locale: options[:locale])[object.wday]
-        when '%^A' then lookup('date.days', locale: options[:locale])[object.wday].upcase
-        when '%b'  then lookup('date.abbreviated_months', locale: options[:locale])[object.mon - 1]
-        when '%^b' then lookup('date.abbreviated_months', locale: options[:locale])[object.mon - 1].upcase
-        when '%B'  then lookup('date.months', locale: options[:locale])[object.mon - 1]
-        when '%^B' then lookup('date.months', locale: options[:locale])[object.mon - 1].upcase
-        when '%p'  then lookup("time.#{ object.hour < 12 ? 'am' : 'pm' }", locale: options[:locale]).upcase if object.respond_to?(:hour) # rubocop:disable Metrics/BlockNesting
-        when '%P'  then lookup("time.#{ object.hour < 12 ? 'am' : 'pm' }", locale: options[:locale]).downcase if object.respond_to?(:hour) # rubocop:disable Metrics/BlockNesting
-        end
-      end
-
-      object.strftime(format)
+      localize_datetime(object, options)
     when Array
-      case object.length
-      when 0
-        ''
-      when 1
-        object[0]
-      when 2
-        two_words_connector = options[:two_words_connector] || lookup('array.two_words_connector', locale: options[:locale])
-
-        raise(MissingLocalizationFormat, "Sentence localization connector ('array.two_words_connector') missing or not passed as option :two_words_connector") unless two_words_connector
-
-        "#{ object[0] }#{ two_words_connector }#{ object[1] }"
-      else
-        last_word_connector = options[:last_word_connector] || lookup('array.last_word_connector', locale: options[:locale])
-        words_connector = options[:words_connector] || lookup('array.words_connector', locale: options[:locale])
-
-        raise(MissingLocalizationFormat, "Sentence localization connector ('array.last_word_connector') missing or not passed as option :last_word_connector") unless last_word_connector
-        raise(MissingLocalizationFormat, "Sentence localization connector ('array.words_connector') missing or not passed as option :words_connector") unless words_connector
-
-        "#{ object[0...-1].join(words_connector) }#{ last_word_connector }#{ object[-1] }"
-      end
+      localize_array(object, options)
     else
       raise(UnLocalizableObject, "The object class #{ object.class } cannot be localized by Tater.")
     end
   end
-  alias l localize
 
   # Lookup a key in the messages hash, using the current locale or an override.
   #
+  # @example Using the default locale, look up a key's value.
+  #   i18n = Tater.new(locale: 'en', messages: { 'en' => { 'greeting' => { 'world' => 'Hello, world!' } } })
+  #   i18n.lookup('greeting.world') # => "Hello, world!"
+  #
   # @param key [String]
+  #   The period-separated key path to look for within our messages.
   # @param locale [String]
-  #   A locale to use instead of our current one.
+  #   A locale to use instead of our current one, if any.
   # @param cascade [Boolean]
   #   A boolean to forcibly set the cascade option for this lookup.
   #
   # @return
   #   Basically anything that can be stored in your messages Hash.
   def lookup(key, locale: nil, cascade: nil)
-    locale = locale.nil? ? @locale : locale
-    cascade = cascade.nil? ? @cascade : cascade
+    locale =
+      if locale.nil?
+        @locale
+      else
+        locale.to_s
+      end
 
-    cached(key, locale, cascade) || begin
-      return nil unless @messages.key?(locale.to_s)
+    cascade = @cascade if cascade.nil?
 
-      path = key.split(SEPARATOR).prepend(locale).map(&:to_s)
+    @cache[locale][cascade][key] ||= begin
+      path = key.split(SEPARATOR)
 
-      message =
-        if cascade
-          while path.length >= 2
-            attempt = @messages.dig(*path)
-
-            break attempt unless attempt.nil?
+      message = @messages[locale].dig(*path)
 
+      if message.nil? && cascade
+        message =
+          while path.length > 1
             path.delete_at(path.length - 2)
+            attempt = @messages[locale].dig(*path)
+
+            break attempt unless attempt.nil?
           end
-        else
-          @messages.dig(*path)
-        end
+      end
 
-      cache(key, locale, cascade, message)
+      message
     end
   end
 
@@ -368,51 +247,140 @@ class Tater
   #   The translated and interpreted string, if found, or any data at the
   #   defined key.
   def translate(key, options = HASH)
-    message =
-      if options.key?(:locales)
-        options[:locales].append(@locale) if @locale && !options[:locales].include?(@locale)
+    if options.empty?
+      message = lookup(key)
 
-        options[:locales].find do |accept|
-          found = lookup(key, locale: accept, cascade: options[:cascade])
-
-          break found unless found.nil?
-        end
+      if message.is_a?(Proc) # rubocop:disable Style/CaseLikeIf
+        message.call(key)
+      elsif message.is_a?(String)
+        message
       else
-        lookup(key, locale: options[:locale], cascade: options[:cascade])
+        "Tater lookup failed: #{ locale }.#{ key }"
       end
+    else
+      message =
+        if options.key?(:locales)
+          options[:locales].append(@locale) if @locale && !options[:locales].include?(@locale)
 
-    # Call procs that should return a string.
-    message = message.call(key, options) if message.is_a?(Proc)
+          options[:locales].find do |accept|
+            found = lookup(key, locale: accept, cascade: options[:cascade])
 
-    Utils.interpolate(message, options) || options[:default] || "Tater lookup failed: #{ options[:locale] || options[:locales] || locale }.#{ key }"
+            break found unless found.nil?
+          end
+        else
+          lookup(key, locale: options[:locale], cascade: options[:cascade])
+        end
+
+      if message.is_a?(Proc) # rubocop:disable Style/CaseLikeIf
+        message.call(key, options.except(:cascade, :default, :locale, :locales))
+      elsif message.is_a?(String)
+        Utils.interpolate(message, options.except(:cascade, :default, :locale, :locales))
+      else
+        options[:default] || "Tater lookup failed: #{ options[:locale] || options[:locales] || locale }.#{ key }"
+      end
+    end
   end
-  alias t translate
 
   private
 
-  # @param key [String]
-  #   The cache key, often in the form "something.nested.like.this"
-  # @param locale [String]
-  #   The locale to store the value for.
-  # @param cascade [Boolean]
-  #   Was this a cascading lookup?
-  # @param message [String]
-  #   The message being cached, often a String.
+  # Localize an Array object.
+  #
+  # @param object [Array<String>]
+  #   The array to localize.
+  # @param options [Hash]
+  #   Options to configure localization.
   # @return [String]
-  #   Whatever value is being cached, often a String.
-  def cache(key, locale, cascade, message)
-    @cache[locale][cascade][key] = message
+  #   The localize array string.
+  def localize_array(object, options)
+    case object.length
+    when 0
+      ''
+    when 1
+      object[0]
+    when 2
+      two_words_connector = options[:two_words_connector] || lookup('array.two_words_connector', locale: options[:locale])
+
+      raise(MissingLocalizationFormat, "Sentence localization connector ('array.two_words_connector') missing or not passed as option :two_words_connector") unless two_words_connector
+
+      "#{ object[0] }#{ two_words_connector }#{ object[1] }"
+    else
+      last_word_connector = options[:last_word_connector] || lookup('array.last_word_connector', locale: options[:locale])
+      words_connector = options[:words_connector] || lookup('array.words_connector', locale: options[:locale])
+
+      raise(MissingLocalizationFormat, "Sentence localization connector ('array.last_word_connector') missing or not passed as option :last_word_connector") unless last_word_connector
+      raise(MissingLocalizationFormat, "Sentence localization connector ('array.words_connector') missing or not passed as option :words_connector") unless words_connector
+
+      "#{ object[0...-1].join(words_connector) }#{ last_word_connector }#{ object[-1] }"
+    end
   end
 
-  # @param key [String]
-  #   The cache key, often in the form "something.nested.like.this"
-  # @param locale [String]
-  #   The locale to store the value for.
-  # @param cascade [Boolean]
-  #   Was this a cascading lookup?
-  # @return [String, nil]
-  #   The cached message or nil.
-  def cached(key, locale, cascade)
-    @cache.dig(locale, cascade, key)
+  # Localize a Date, DateTime, or Time object.
+  #
+  # @param object [Date, DateTime, Time]
+  #   The date-ish object to localize.
+  # @param options [Hash]
+  #   Options to configure localization.
+  # @return [String]
+  #   The localized date string.
+  def localize_datetime(object, options)
+    frmt = options[:format] || DEFAULT
+    loc = options[:locale]
+    format = lookup("#{ object.class.to_s.downcase }.formats.#{ frmt }", locale: loc) || frmt
+
+    # Heavily cribbed from I18n, many thanks to the people who sorted this out
+    # before I worked on this library.
+    format = format.gsub(SUBSTITUTION_REGEX) do |match|
+      case match
+      when '%a'  then lookup('date.abbreviated_days', locale: loc)[object.wday]
+      when '%^a' then lookup('date.abbreviated_days', locale: loc)[object.wday].upcase
+      when '%A'  then lookup('date.days', locale: loc)[object.wday]
+      when '%^A' then lookup('date.days', locale: loc)[object.wday].upcase
+      when '%b'  then lookup('date.abbreviated_months', locale: loc)[object.mon - 1]
+      when '%^b' then lookup('date.abbreviated_months', locale: loc)[object.mon - 1].upcase
+      when '%B'  then lookup('date.months', locale: loc)[object.mon - 1]
+      when '%^B' then lookup('date.months', locale: loc)[object.mon - 1].upcase
+      when '%p'  then lookup("time.#{ object.hour < 12 ? 'am' : 'pm' }", locale: loc).upcase if object.respond_to?(:hour)
+      when '%P'  then lookup("time.#{ object.hour < 12 ? 'am' : 'pm' }", locale: loc).downcase if object.respond_to?(:hour)
+      end
+    end
+
+    if format.include?('%')
+      object.strftime(format)
+    else
+      format
+    end
+  end
+
+  # Localize a Numeric object.
+  #
+  # @param object [Array<String>, Date, Time, DateTime, Numeric]
+  #   The object to localize.
+  # @param options [Hash]
+  #   Options to configure localization.
+  # @return [String]
+  #   The localized numeric string.
+  def localize_numeric(object, options)
+    delimiter = options[:delimiter] || lookup('numeric.delimiter', locale: options[:locale])
+    separator = options[:separator] || lookup('numeric.separator', locale: options[:locale])
+    precision = options[:precision] || 2
+
+    raise(MissingLocalizationFormat, "Numeric localization delimiter ('numeric.delimiter') missing or not passed as option :delimiter") unless delimiter
+    raise(MissingLocalizationFormat, "Numeric localization separator ('numeric.separator') missing or not passed as option :separator") unless separator
+
+    # Break the number up into integer and fraction parts.
+    integer = Utils.string_from_numeric(object)
+    integer, fraction = integer.split('.') unless object.is_a?(Integer)
+
+    if object >= 1_000
+      integer.gsub!(DELIMITING_REGEX) do |number|
+        "#{ number }#{ delimiter }"
+      end
+    end
+
+    if precision.zero? || fraction.nil?
+      integer
+    else
+      "#{ integer }#{ separator }#{ fraction.ljust(precision, '0').slice(0, precision) }"
+    end
   end
 end

data/test/tater_test.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
-require_relative '../lib/tater'
-require 'minitest/autorun'
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+
 require 'date'
+require 'minitest/autorun'
+require 'tater'
 
 describe Tater do
   describe Tater::Utils do
@@ -59,6 +61,20 @@ describe Tater do
         assert_equal '1.0', Tater::Utils.string_from_numeric(BigDecimal('1'))
       end
     end
+
+    describe '#interpolation_string?' do
+      def is?(arg)
+        Tater::Utils.interpolation_string?(arg)
+      end
+
+      it 'checks whether a string contains interpolation placeholders' do
+        assert is?('Hey %{there}!')
+        assert is?('Hey %<there>s!')
+        refute is?('Nah, this is fine')
+        refute is?("<b>HTML shouldn't count")
+        refute is?("A single % shouldn't count")
+      end
+    end
   end
 
   describe '#available?' do
@@ -118,7 +134,7 @@ describe Tater do
     end
 
     it 'updates the available list when new messages are loaded' do
-      i18n.load(messages: { 'added' => { 'hey' => 'yeah' }})
+      i18n.load(messages: { 'added' => { 'hey' => 'yeah' } })
 
       assert_equal %w[en delimiter_only separator_only fr added].sort, i18n.available.sort
     end
@@ -141,6 +157,10 @@ describe Tater do
       assert_nil i18n.lookup('nope')
     end
 
+    it 'returns arbitrary data at keys' do
+      assert_equal({ 'key' => 'This key is deeper' }, i18n.lookup('deep'))
+    end
+
     it 'cascades' do
       assert_equal 'Delicious', i18n.lookup('cascade.nope.tacos', cascade: true)
       assert_equal 'Whoaa', i18n.lookup('cascade.another.nope.crazy', cascade: true)
@@ -162,8 +182,8 @@ describe Tater do
       assert_equal 'This key is deeper', i18n.translate('deep.key')
     end
 
-    it 'returns a hash for nested keys' do
-      assert_equal({ 'key' => 'This key is deeper' }, i18n.translate('deep'))
+    it 'does not return a hash for nested keys' do
+      assert_equal 'Tater lookup failed: en.deep', i18n.translate('deep')
     end
 
     it 'interpolates additional variables' do
@@ -180,10 +200,6 @@ describe Tater do
       assert_equal 'Tater lookup failed: en.nope', i18n.translate('nope')
     end
 
-    it 'is aliased as t' do
-      assert_equal 'This is a title', i18n.t('title')
-    end
-
     it 'cascades lookups' do
       assert_equal 'Tater lookup failed: en.cascade.another.nope.crazy', i18n.translate('cascade.another.nope.crazy', cascade: false)
       assert_equal 'Tater lookup failed: en.cascade.nope.tacos', i18n.translate('cascade.nope.tacos')
@@ -201,9 +217,12 @@ describe Tater do
       assert_equal 'Tater lookup failed: ["fr", "en"].neither', i18n.translate('neither', locales: %w[fr en])
     end
 
-    it 'finds Ruby files as well' do
+    it 'finds Ruby files' do
       assert_equal 'Hey ruby!', i18n.translate('ruby')
-      assert_equal 'Hey options!', i18n.translate('options', options: 'options')
+    end
+
+    it 'does not interpolate messages returned by procs' do
+      assert_equal 'Hey %{options}!', i18n.translate('options', options: 'options')
     end
   end
 
@@ -265,10 +284,28 @@ describe Tater do
       assert_equal '1NAH12', i18n.localize(BigDecimal('1.12'))
     end
 
-    it 'accomodates precision' do
-      assert_equal '10NAH00', i18n.localize(BigDecimal('10'))
-      assert_equal '10', i18n.localize(BigDecimal('10'), precision: 0)
-      assert_equal '10NAH00', i18n.localize(BigDecimal('10.00234'))
+    describe 'precision option' do
+      it 'defaults to 2' do
+        assert_equal '10NAH00', i18n.localize(BigDecimal('10'))
+        assert_equal '10NAH00', i18n.localize(10.0)
+      end
+
+      it 'defaults to zero for integers' do
+        assert_equal '10', i18n.localize(10)
+      end
+
+      it 'removes fractional pieces when the precision is 0' do
+        assert_equal '10', i18n.localize(BigDecimal('10.123456'), precision: 0)
+        assert_equal '10', i18n.localize(10.123456, precision: 0)
+
+        assert_equal '10', i18n.localize(BigDecimal('10.12'), precision: 0)
+        assert_equal '10', i18n.localize(10.12, precision: 0)
+      end
+
+      it 'truncates long values to the desired precision' do
+        assert_equal '10NAH00', i18n.localize(BigDecimal('10.00234'))
+        assert_equal '10NAH00', i18n.localize(10.00234)
+      end
     end
 
     it 'allows overriding the delimiter and separator' do
@@ -296,10 +333,6 @@ describe Tater do
       end
     end
 
-    it 'is aliased l' do
-      assert_equal '1970/1/1', i18n.l(Date.new(1970, 1, 1))
-    end
-
     describe 'month, day, and AM/PM names' do
       let :i18n do
         Tater.new(path: File.expand_path('test/fixtures'), locale: 'fr')

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tater
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Evan Lecklider
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-15 00:00:00.000000000 Z
+date: 2021-12-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-packaging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Minimal internationalization and localization library.
 email:
 - evan@lecklider.com
@@ -74,7 +130,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
-- README.md
+- README.org
 - lib/tater.rb
 - test/fixtures/another.yml
 - test/fixtures/fixtures.yml
@@ -86,8 +142,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/evanleck/tater/issues
+  rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/evanleck/tater
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -102,8 +159,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '2.0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key: 
+rubygems_version: 3.2.32
+signing_key:
 specification_version: 4
 summary: Minimal internationalization and localization library.
 test_files: