tater 1.3.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fe610aeeb910795f9f07f52bdbfa529a6f10ac5b807a8252a0d0f50e24ca6a6
-  data.tar.gz: a4154b7803f31babbb012f2f65f36b16f4ea929a43f30a9388b0be10d717f1d7
+  metadata.gz: eb7166fcdf9b548f8837e4411bfe5d83712f202e1de27c299fa0e5694b50bc2b
+  data.tar.gz: ab3f53e56fa8538f39ce59ba9f2e42496e5bea116a880fc26e23ad2091e5e93c
 SHA512:
-  metadata.gz: e478a0bb35614afcf58b79f4d2511f02a25772decbf5e1ea5f4ccbb574ea1699fb7f13bc7174aca5ee12cb6fe0130f7a5466a069cc1fca0435569a6e5db2c58d
-  data.tar.gz: f7f31381024e298d33cdf53ae6609218ab671d27c2fd3c0f1e4f8595a28d87f2f46b6f9d03b27e2c186aec6fc4c4a707850287ca98420ff2ef7a2444d8c7fef9
+  metadata.gz: ceb821ff34a086711feb0df9e21a7aa4c7891a3e84fc52a9cf62d5972462c6ab0a5f81eef2ab820ef95df7211dda82e2a56299a1ced017e468c50358b6e537db
+  data.tar.gz: 2ad3f4c078bb63e39b5650254f92cb3859c39c73f4eaf2dfae18320e60712bf2c632e42c38770c39a456ee62f13fbf6262e1fef527846c17c53d7ebd859fa6de

data/{README.md → README.org}

@@ -1,112 +1,111 @@
-# Tater 
+* Tater
 
-[![Gem Version](https://badge.fury.io/rb/tater.svg)](https://badge.fury.io/rb/tater)
-[![Build Status](https://secure.travis-ci.org/evanleck/tater.svg)](https://travis-ci.org/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 as:
+Or install it yourself by running:
 
-```sh
+#+begin_src sh
 gem install tater
-```
-
+#+end_src
 
-## Usage
+** Usage
 
-```ruby
+#+begin_src ruby
 require 'tater'
 
 messages = {
-  'some' => {
-    'key' => 'This here string!'
-  },
-  'interpolated' => 'Hello %{you}!'
+  'en' => {
+    'some' => {
+      'key' => 'This here string!'
+    },
+    'interpolated' => 'Hello %{you}!'
+  }
 }
 
-i18n = Tater.new
+i18n = Tater.new(locale: 'en')
 i18n.load(messages: messages)
 
+# OR
+i18n = Tater.new(locale: 'en', messages: messages)
+
 # Basic lookup:
 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'
@@ -169,96 +168,95 @@ 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 = {
-  'login' => {
-    'title' => 'Login',
-    'description' => 'Normal description.'
+  'en' => {
+    'login' => {
+      'title' => 'Login',
+      'description' => 'Normal description.'
 
-    'special' => {
-      'title' => 'Special Login'
+      'special' => {
+        'title' => 'Special Login'
+      }
     }
   }
 }
 
-i18n = Tater.new(messages: messages)
+i18n = Tater.new(locale: 'en', messages: messages)
 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: {
+  'en' => {
     ruby: proc do |key, options = {}|
       "Hey #{ key }!"
     end
   }
 }
-```
-
+#+end_src
 
-## Multiple Locales
+** Multiple locales
 
-If you like to check multiple locales and pull the first matching one out, you
-can pass the `:locales` option an array of top-level locale keys.
+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
+with an array of top-level locale keys.
 
-```ruby
+#+begin_src ruby
 messages = {
   'en' => {
     'title' => 'Login',
@@ -272,31 +270,28 @@ messages = {
 i18n = Tater.new(messages: messages)
 i18n.translate('title', locales: %w[fr en]) # => 'la connexion'
 i18n.translate('description', locales: %w[fr en]) # => 'English description.'
-```
 
-Locales will tried in order and which one matches first will be returned.
+# OR
+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

@@ -6,20 +6,21 @@ require 'yaml'
 # designed for speed and simplicity.
 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. Note that modification is done in-place,
-    #   not on a copy of the object.
+    #   The target Hash to merge into.
     # @param from [Hash]
     #   The Hash to copy values from.
-    def self.deep_merge!(to, from)
-      to.merge!(from) do |_key, left, right|
+    # @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)
+          Utils.deep_merge(left, right)
         else
           right
         end
@@ -29,18 +30,32 @@ class Tater
     # Transform keys all the way down.
     #
     # @param hash [Hash]
-    #   The Hash to modify. Note that modification is done in-place, not on a copy
-    #   of the object.
-    def self.deep_stringify_keys!(hash)
-      hash.transform_keys!(&:to_s).transform_values! do |value|
+    #   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)
+          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]
@@ -49,8 +64,9 @@ class Tater
     #   The values to interpolate into the target string.
     #
     # @return [String]
-    def self.interpolate(string, options = {})
+    def self.interpolate(string, options = HASH)
       return string unless string.is_a?(String)
+      return string if options.empty?
 
       format(string, options)
     end
@@ -71,8 +87,8 @@ class Tater
   end
 
   DEFAULT = 'default'
-  DEFAULT_LOCALE = 'en'
   DELIMITING_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/.freeze
+  HASH = {}.freeze
   SEPARATOR = '.'
   SUBSTITUTION_REGEX = /%(|\^)[aAbBpP]/.freeze
 
@@ -82,7 +98,16 @@ class Tater
   # @return [Hash]
   attr_reader :messages
 
-  def initialize(path: nil, messages: nil, locale: DEFAULT_LOCALE, cascade: false)
+  # @param cascade [Boolean]
+  #   A boolean indicating if lookups should cascade by default.
+  # @param locale [String]
+  #   The default locale.
+  # @param messages [Hash]
+  #   A hash of messages ready to be loaded in.
+  # @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 = {}
@@ -98,11 +123,11 @@ class Tater
     @cascade
   end
 
-  # An array of the available locale codes.
+  # An array of the available locale codes found in loaded messages.
   #
   # @return [Array]
   def available
-    messages.keys.map(&:to_s)
+    @available ||= messages.keys
   end
 
   # Is this locale available in our current set of messages?
@@ -113,24 +138,36 @@ class Tater
   end
 
   # Load messages into our internal cache, either from a path containing YAML
-  # files or a collection of messages.
+  # files or a Hash of messages.
   #
   # @param path [String]
   #   A path to search for YAML or Ruby files to load messages from.
   # @param messages [Hash]
   #   A hash of messages ready to be loaded in.
   def load(path: nil, messages: nil)
+    return if path.nil? && messages.nil?
+
     if path
       Dir.glob(File.join(path, '**', '*.{yml,yaml}')).each do |file|
-        Utils.deep_merge!(@messages, YAML.load_file(file))
+        @messages = Utils.deep_merge(@messages, YAML.load_file(file))
       end
 
       Dir.glob(File.join(path, '**', '*.rb')).each do |file|
-        Utils.deep_merge!(@messages, Utils.deep_stringify_keys!(eval(IO.read(file), binding, file)))
+        @messages = Utils.deep_merge(@messages, Utils.deep_stringify_keys(eval(IO.read(file), binding, file))) # rubocop:disable Security/Eval
       end
     end
 
-    Utils.deep_merge!(@messages, Utils.deep_stringify_keys!(messages)) if messages
+    @messages = Utils.deep_merge(@messages, Utils.deep_stringify_keys(messages)) if messages
+    @messages = Utils.deep_freeze(@messages)
+
+    # Gotta recalculate available locales after updating.
+    remove_instance_variable(:@available) if instance_variable_defined?(:@available)
+
+    # Not only does this clear our cache but it establishes the basic structure
+    # that we rely on in other methods.
+    @messages.each_key do |key|
+      @cache[key] = { true => {}, false => {} }
+    end
   end
 
   # Set the current locale, if it's available.
@@ -143,7 +180,7 @@ class Tater
 
   # Localize an Array, Date, Time, DateTime, or Numeric object.
   #
-  # @param object [Date, Time, DateTime, Numeric]
+  # @param object [Array<String>, Date, Time, DateTime, Numeric]
   #   The object to localize.
   # @param options [Hash]
   #   Options to configure localization.
@@ -166,50 +203,50 @@ class Tater
   #
   # @return [String]
   #   A localized version of the object passed in.
-  def localize(object, options = {})
-    format_key = options.delete(:format) || DEFAULT
-    locale_override = options.delete(:locale)
-
+  def localize(object, options = HASH)
     case object
     when String
       object
     when Numeric
-      delimiter = options.delete(:delimiter) || lookup('numeric.delimiter', locale_override)
-      separator = options.delete(:separator) || lookup('numeric.separator', locale_override)
-      precision = options.delete(:precision) || 2
+      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 }"
+      # 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 integer.length > 3
+        integer.gsub!(DELIMITING_REGEX) do |number|
+          "#{ number }#{ delimiter }"
+        end
       end
 
-      if precision.zero?
+      if precision.zero? || fraction.nil?
         integer
       else
-        [integer, fraction&.ljust(precision, '0')].compact.join(separator)
+        "#{ integer }#{ separator }#{ fraction.ljust(precision, '0').slice(0, precision) }"
       end
     when Date, Time, DateTime
-      key = object.class.to_s.downcase
-      format = lookup("#{ key }.formats.#{ format_key }", locale_override) || format_key
+      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_override)[object.wday]
-        when '%^a' then lookup('date.abbreviated_days', locale_override)[object.wday].upcase
-        when '%A'  then lookup('date.days', locale_override)[object.wday]
-        when '%^A' then lookup('date.days', locale_override)[object.wday].upcase
-        when '%b'  then lookup('date.abbreviated_months', locale_override)[object.mon - 1]
-        when '%^b' then lookup('date.abbreviated_months', locale_override)[object.mon - 1].upcase
-        when '%B'  then lookup('date.months', locale_override)[object.mon - 1]
-        when '%^B' then lookup('date.months', locale_override)[object.mon - 1].upcase
-        when '%p'  then lookup("time.#{ object.hour < 12 ? 'am' : 'pm' }", locale_override).upcase if object.respond_to?(:hour) # rubocop:disable Metrics/BlockNesting
-        when '%P'  then lookup("time.#{ object.hour < 12 ? 'am' : 'pm' }", locale_override).downcase if object.respond_to?(:hour) # rubocop:disable Metrics/BlockNesting
+        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
 
@@ -221,14 +258,14 @@ class Tater
       when 1
         object[0]
       when 2
-        two_words_connector = options.delete(:two_words_connector) || lookup('array.two_words_connector', locale_override)
+        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.delete(:last_word_connector) || lookup('array.last_word_connector', locale_override)
-        words_connector = options.delete(:words_connector) || lookup('array.words_connector', locale_override)
+        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
@@ -244,28 +281,36 @@ class Tater
   # Lookup a key in the messages hash, using the current locale or an override.
   #
   # @param key [String]
-  # @param locale_override [String]
+  # @param locale [String]
   #   A locale to use instead of our current one.
-  # @param cascade_override [Boolean]
+  # @param cascade [Boolean]
   #   A boolean to forcibly set the cascade option for this lookup.
   #
   # @return
-  #   Basically anything that can be stored in YAML, including nil.
-  def lookup(key, locale_override = nil, cascade_override = nil)
-    path = key.split(SEPARATOR).prepend(locale_override || locale).map(&:to_s)
+  #   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
+
+    cached(key, locale, cascade) || begin
+      return nil unless @messages.key?(locale.to_s)
 
-    if cascade_override.nil? ? @cascade : cascade_override
-      while path.length >= 2 do
-        attempt = @messages.dig(*path)
+      path = key.split(SEPARATOR).prepend(locale).map(&:to_s)
 
-        if attempt
-          break attempt
+      message =
+        if cascade
+          while path.length >= 2
+            attempt = @messages.dig(*path)
+
+            break attempt unless attempt.nil?
+
+            path.delete_at(path.length - 2)
+          end
         else
-          path.delete_at(path.length - 2)
+          @messages.dig(*path)
         end
-      end
-    else
-      @messages.dig(*path)
+
+      cache(key, locale, cascade, message)
     end
   end
 
@@ -285,20 +330,18 @@ class Tater
   #   An array of locales to look within.
   #
   # @return [Boolean]
-  def includes?(key, options = {})
-    cascade_override = options.delete(:cascade)
-    locale_override = options.delete(:locale)
-    locales = options.delete(:locales)
-
+  def includes?(key, options = HASH)
     message =
-      if locale_override || !locales
-        lookup(key, locale_override, cascade_override)
-      else
-        locales.find do |accept|
-          found = lookup(key, accept, cascade_override)
+      if options.key?(:locales)
+        options[:locales].append(@locale) if @locale && !options[:locales].include?(@locale)
+
+        options[:locales].find do |accept|
+          found = lookup(key, locale: accept, cascade: options[:cascade])
 
-          break found if found
+          break found unless found.nil?
         end
+      else
+        lookup(key, locale: options[:locale], cascade: options[:cascade])
       end
 
     !message.nil?
@@ -308,7 +351,7 @@ class Tater
   # It's effectively a combination of #lookup and #interpolate.
   #
   # @example
-  #   Tater.new(messages: { 'en' => { 'hi' => 'Hello' }}).translate('hi') # => 'Hello'
+  #   Tater.new(locale: 'en', messages: { 'en' => { 'hi' => 'Hello' }}).translate('hi') # => 'Hello'
   #
   # @param key [String]
   #   The period-separated key path to look within our messages for.
@@ -320,36 +363,61 @@ class Tater
   # @option options [String] :default
   #   A default string to return, should lookup fail.
   # @option options [String] :locale
-  #   A specific locale to lookup within. This will take precedence over the
-  #   :locales option.
+  #   A specific locale to lookup within.
   # @option options [Array<String>] :locales
-  #   An array of locales to look within.
+  #   An array of locales to look within. This will take precedence over the
+  #   :locale option and will append the default :locale option passed during
+  #   initialization if present.
   #
   # @return [String]
   #   The translated and interpreted string, if found, or any data at the
   #   defined key.
-  def translate(key, options = {})
-    cascade_override = options.delete(:cascade)
-    locale_override = options.delete(:locale)
-    locales = options.delete(:locales)
-
+  def translate(key, options = HASH)
     message =
-      if locale_override || !locales
-        lookup(key, locale_override, cascade_override)
-      else
-        locales.find do |accept|
-          found = lookup(key, accept, cascade_override)
+      if options.key?(:locales)
+        options[:locales].append(@locale) if @locale && !options[:locales].include?(@locale)
+
+        options[:locales].find do |accept|
+          found = lookup(key, locale: accept, cascade: options[:cascade])
 
-          break found if found
+          break found unless found.nil?
         end
+      else
+        lookup(key, locale: options[:locale], cascade: options[:cascade])
       end
 
     # Call procs that should return a string.
-    if message.is_a?(Proc)
-      message = message.call(key, options)
-    end
+    message = message.call(key, options) if message.is_a?(Proc)
 
-    Utils.interpolate(message, options) || options.delete(:default) { "Tater lookup failed: #{ locale_override || locales || locale }.#{ key }" }
+    Utils.interpolate(message, options) || options[:default] || "Tater lookup failed: #{ options[:locale] || options[:locales] || locale }.#{ key }"
   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.
+  # @return [String]
+  #   Whatever value is being cached, often a String.
+  def cache(key, locale, cascade, message)
+    @cache[locale][cascade][key] = message
+  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)
+  end
 end

data/test/fixtures/ruby.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 {
   en: {
-    ruby: proc do |key, options = {}|
+    ruby: proc do |key, _options = {}|
       "Hey #{ key }!"
     end,
-    options: proc do |_key, options = {}|
-      "Hey %{options}!"
+    options: proc do |_key, _options = {}|
+      'Hey %{options}!'
     end
   }
 }

data/test/tater_test.rb

@@ -5,24 +5,34 @@ require 'date'
 
 describe Tater do
   describe Tater::Utils do
-    describe '#deep_merge!' do
-      it 'deeply merges two hashes, modifying the first' do
+    describe '#deep_merge' do
+      it 'deeply merges two hashes, returning a new one' do
         first = { 'one' => 'one', 'two' => { 'three' => 'three' } }
         second = { 'two' => { 'four' => 'four' } }
 
-        Tater::Utils.deep_merge!(first, second)
+        third = Tater::Utils.deep_merge(first, second)
 
-        assert_equal({ 'one' => 'one', 'two' => { 'three' => 'three', 'four' => 'four' } }, first)
+        assert_equal({ 'one' => 'one', 'two' => { 'three' => 'three', 'four' => 'four' } }, third)
       end
     end
 
-    describe '#deep_stringify_keys!' do
-      it 'converts all keys into strings, recursively modifying the hash passed in' do
+    describe '#deep_stringify_keys' do
+      it 'converts all keys into strings, recursively' do
         start = { en: { login: { title: 'Hello!' } } }
+        finish = Tater::Utils.deep_stringify_keys(start)
 
-        Tater::Utils.deep_stringify_keys!(start)
+        assert_equal({ 'en' => { 'login' => { 'title' => 'Hello!' } } }, finish)
+      end
+    end
 
-        assert_equal({ 'en' => { 'login' => { 'title' => 'Hello!' } } }, start)
+    describe '#deep_freeze' do
+      it 'freezes the keys and values, recursively' do
+        start = Tater::Utils.deep_stringify_keys({ en: { login: { title: 'Hello!' } } })
+        finish = Tater::Utils.deep_freeze(start)
+
+        assert finish.frozen?
+        assert finish.keys.all?(&:frozen?)
+        assert finish.values.all?(&:frozen?)
       end
     end
 
@@ -31,25 +41,29 @@ describe Tater do
         assert_equal 'this thing', Tater::Utils.interpolate('this %{what}', what: 'thing')
       end
 
-      it 'raises a KeyError when an argument is missing' do
+      it 'raises a KeyError when an argument is missing (but options are passed)' do
         assert_raises(KeyError) do
-          Tater::Utils.interpolate('this %{what}')
+          Tater::Utils.interpolate('this %{what}', nope: 'thing')
         end
       end
+
+      it 'returns the string unchanged when options are empty (does not raise a KeyError)' do
+        assert_equal 'this %{what}', Tater::Utils.interpolate('this %{what}')
+      end
     end
 
     describe '#string_from_numeric' do
       it 'converts numerics to decimal-ish strings' do
         assert_equal '1', Tater::Utils.string_from_numeric(1)
         assert_equal '1.0', Tater::Utils.string_from_numeric(1.0)
-        assert_equal '1.0', Tater::Utils.string_from_numeric(BigDecimal(1))
+        assert_equal '1.0', Tater::Utils.string_from_numeric(BigDecimal('1'))
       end
     end
   end
 
   describe '#available?' do
     let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'))
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
     end
 
     it 'tells you if the locale is available' do
@@ -84,6 +98,14 @@ describe Tater do
 
       assert_instance_of(Hash, i18n.messages)
     end
+
+    it 'freezes messages after loading' do
+      i18n = Tater.new(messages: { 'hey' => 'Oh hi' })
+
+      assert i18n.messages.frozen?
+      assert i18n.messages.keys.all?(&:frozen?)
+      assert i18n.messages.values.all?(&:frozen?)
+    end
   end
 
   describe '#available' do
@@ -94,11 +116,17 @@ describe Tater do
     it 'returns an array with the available locales (i.e. the top-level keys in our messages hash)' do
       assert_equal %w[en delimiter_only separator_only fr].sort, i18n.available.sort
     end
+
+    it 'updates the available list when new messages are loaded' do
+      i18n.load(messages: { 'added' => { 'hey' => 'yeah' } })
+
+      assert_equal %w[en delimiter_only separator_only fr added].sort, i18n.available.sort
+    end
   end
 
   describe '#lookup' do
     let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'))
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
     end
 
     it 'returns keys from messages' do
@@ -114,16 +142,16 @@ describe Tater do
     end
 
     it 'cascades' do
-      assert_equal 'Delicious', i18n.lookup('cascade.nope.tacos', nil, true)
-      assert_equal 'Whoaa', i18n.lookup('cascade.another.nope.crazy', nil, true)
-      assert_nil i18n.lookup('cascade.another.nope.crazy', nil, false)
+      assert_equal 'Delicious', i18n.lookup('cascade.nope.tacos', cascade: true)
+      assert_equal 'Whoaa', i18n.lookup('cascade.another.nope.crazy', cascade: true)
+      assert_nil i18n.lookup('cascade.another.nope.crazy', cascade: false)
       assert_nil i18n.lookup('cascade.nahhhhhh')
     end
   end
 
   describe '#translate' do
     let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'))
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
     end
 
     it 'translates strings' do
@@ -181,7 +209,7 @@ describe Tater do
 
   describe '#localize' do
     let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'))
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
     end
 
     let :fr do
@@ -237,6 +265,30 @@ describe Tater do
       assert_equal '1NAH12', i18n.localize(BigDecimal('1.12'))
     end
 
+    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
       assert_equal '10WOO000NAH12', i18n.localize(10_000.12, delimiter: 'WOO')
       assert_equal '10TURKEYS000YA12', i18n.localize(10_000.12, separator: 'YA')
@@ -332,7 +384,7 @@ describe Tater do
 
   describe '#locale=' do
     let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'))
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
     end
 
     it 'overrides the locale when available' do
@@ -366,7 +418,7 @@ describe Tater do
 
   describe '#includes?' do
     let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'))
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
     end
 
     it 'tells you if you have a translation' do

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tater
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Evan Lecklider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-19 00:00:00.000000000 Z
+date: 2021-06-21 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
@@ -24,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: 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'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +66,48 @@ 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-performance
+  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-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
@@ -46,7 +116,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
-- README.md
+- README.org
 - lib/tater.rb
 - test/fixtures/another.yml
 - test/fixtures/fixtures.yml
@@ -74,13 +144,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '2.0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: Minimal internationalization and localization library.
 test_files:
+- test/fixtures/another.yml
+- test/fixtures/fixtures.yml
 - test/fixtures/messages/more.yml
 - test/fixtures/ruby.rb
-- test/fixtures/fixtures.yml
-- test/fixtures/another.yml
 - test/tater_test.rb