tater 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '00580e7b14eb0c1f1bc26b9a8cc2470638aa06f2f9800b4a4c542de913fffcb4'
-  data.tar.gz: f807ce661a2bed8ca9526f309c1548ddf292f034cbcaeae4223a385f89296c86
+  metadata.gz: 16fddfa1cedd9af51e3d2e04422a083a16ee055e1102ad4482bfb28beee3be78
+  data.tar.gz: 73273faf3a6bb5842d6adc2854ca98e81363efd0c45835de07fc2e4d807effa2
 SHA512:
-  metadata.gz: 8ff891fe31f924f41c5bd20aaa0b58c39659a2e0e72cabd4cfd55df79d2e237daaabe2bb717415eca782f814dcd1322737a861f23fd37449e4f8516a71ea197e
-  data.tar.gz: f231dcbca0ca5826a4c99f92afa6c98514985c262a66f473ddb8696d754e849e6c50d371cf82c056e395565b199d6179d665b28b580cade63aa24932c4a378e6
+  metadata.gz: a9da7fc7081b2043891c83f6ef46c1facdff44f85175ce5052af04a0e6f22bb82ffb0505a29d24a7d2a91ba00e81c5b8fccdb1c6b7118de48680639e474a7f13
+  data.tar.gz: 0ccb2a820ea03144b96319c61eb0b645ca86002cf88c657b906669b39702dbdefb83e009a3b34fb5adda4a9fd47deaa30fbd0c0580ff34b80c9e9c5d4051a204

data/README.md

@@ -27,7 +27,7 @@ And then execute:
 bundle
 ```
 
-Or install it yourself as:
+Or install it yourself by running:
 
 ```sh
 gem install tater
@@ -40,15 +40,20 @@ gem install tater
 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!'
 
@@ -56,7 +61,26 @@ i18n.translate('some.key') # => 'This here string!'
 i18n.translate('interpolated', you: 'world') # => 'Hello world!'
 ```
 
-## Numeric 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
+en:
+  array:
+    last_word_connector: ", and "
+    two_words_connector: " and "
+    words_connector: ", "
+```
+
+```ruby
+i18n.localize(%w[tacos enchiladas burritos]) # => "tacos, enchiladas, and burritos"
+```
+
+
+## Numeric localization
 
 Numeric localization (`Numeric`, `Integer`, `Float`, and `BigDecimal`) require
 filling in a separator and delimiter. For example:
@@ -81,7 +105,7 @@ i18n.localize(1000.2, delimiter: '_', separator: '+') # => "1_000+20"
 ```
 
 
-## Date and Time Localization
+## Date and time localization
 
 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
@@ -166,24 +190,26 @@ i18n.localize(Date.new(1970, 1, 1), format: 'day') # => 'jeudi'
 ```
 
 
-## Cascading Lookups
+## Cascading lookups
 
 Lookups can be cascaded, i.e. pieces of the scope of the can be lopped off
 incrementally.
 
 ```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'
 
@@ -218,14 +244,14 @@ Tater.new.translate('nope', default: 'Yep!') # => 'Yep!'
 ```
 
 
-## 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
 {
-  en: {
+  'en' => {
     ruby: proc do |key, options = {}|
       "Hey #{ key }!"
     end
@@ -234,10 +260,11 @@ Ruby file returns a `Hash` when evalled.
 ```
 
 
-## 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
 messages = {
@@ -253,9 +280,14 @@ messages = {
 i18n = Tater.new(messages: messages)
 i18n.translate('title', locales: %w[fr en]) # => 'la connexion'
 i18n.translate('description', locales: %w[fr en]) # => 'English description.'
+
+# OR
+i18n = Tater.new(messages: messages, locales: %w[fr en])
+i18n.translate('title') # => 'la connexion'
+i18n.translate('description') # => 'English description.'
 ```
 
-Locales will tried in order and which one matches first will be returned.
+Locales will be tried in order and whichever one matches first will be returned.
 
 
 ## Limitations

data/lib/tater.rb

@@ -12,14 +12,14 @@ class Tater
     # 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 +29,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 +63,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 +86,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 +97,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 +122,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 +137,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.
@@ -141,9 +177,9 @@ class Tater
     @locale = locale.to_s if available?(locale)
   end
 
-  # Localize a Date, Time, DateTime, or Numeric object.
+  # 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.
@@ -156,20 +192,24 @@ class Tater
   #   The delimiter to use when localizing numberic values.
   # @option options [String] :separator
   #   The separator to use when localizing numberic values.
+  # @option options [String] :two_words_connector
+  #   The string used to join two array elements together e.g. " and ".
+  # @option options [String] :words_connector
+  #   The string used to connect multiple array elements e.g. ", ".
+  # @option options [String] :last_word_connector
+  #   The string used to connect the final element with preceding array elements
+  #   e.g. ", and ".
   #
   # @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
@@ -186,27 +226,47 @@ class Tater
         [integer, fraction&.ljust(precision, '0')].compact.join(separator)
       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
 
       object.strftime(format)
+    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
     else
       raise(UnLocalizableObject, "The object class #{ object.class } cannot be localized by Tater.")
     end
@@ -216,36 +276,77 @@ 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
 
+  # Check that there's a key at the given path.
+  #
+  # @param key [String]
+  #   The period-separated key path to look within our messages for.
+  # @param options [Hash]
+  #   Options to pass to the #lookup method, including locale overrides.
+  #
+  # @option options [Boolean] :cascade
+  #   Should this lookup cascade or not? Can override @cascade.
+  # @option options [String] :locale
+  #   A specific locale to lookup within. This will take precedence over the
+  #   :locales option.
+  # @option options [Array<String>] :locales
+  #   An array of locales to look within.
+  #
+  # @return [Boolean]
+  def includes?(key, options = HASH)
+    message =
+      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 unless found.nil?
+        end
+      else
+        lookup(key, locale: options[:locale], cascade: options[:cascade])
+      end
+
+    !message.nil?
+  end
+
   # Translate a key path and optional interpolation arguments into a string.
   # 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.
@@ -257,36 +358,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/fixtures.yml

@@ -8,6 +8,11 @@ en:
   deep:
     key: 'This key is deeper'
 
+  array:
+    last_word_connector: ", and "
+    two_words_connector: " and "
+    words_connector: ", "
+
   date:
     formats:
       default: '%Y/%-m/%-d'

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
+
+    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_equal({ 'en' => { 'login' => { 'title' => 'Hello!' } } }, 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,36 @@ 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
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'fr')
+    end
+
+    it 'localizes arrays' do
+      assert_equal 'tacos and burritos', i18n.localize(%w[tacos burritos])
+      assert_equal 'tacos', i18n.localize(%w[tacos])
+      assert_equal 'tacos, enchiladas, and burritos', i18n.localize(%w[tacos enchiladas burritos])
+
+      assert_equal 'tacos + enchiladas ++ burritos', fr.localize(%w[tacos enchiladas burritos], words_connector: ' + ', last_word_connector: ' ++ ')
+      assert_equal 'tacostwoburritos', fr.localize(%w[tacos burritos], two_words_connector: 'two')
+
+      assert_raises(Tater::MissingLocalizationFormat) do
+        fr.localize(%w[tacos burritos])
+      end
+
+      assert_raises(Tater::MissingLocalizationFormat) do
+        fr.localize(%w[tacos burritos], last_word_connector: 'last', words_connector: 'words')
+      end
+
+      assert_raises(Tater::MissingLocalizationFormat) do
+        fr.localize(%w[tacos burritos], last_word_connector: 'last')
+      end
+
+      assert_raises(Tater::MissingLocalizationFormat) do
+        fr.localize(%w[tacos burritos], words_connector: 'words')
+      end
     end
 
     it 'localizes Dates' do
@@ -303,7 +360,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
@@ -334,4 +391,29 @@ describe Tater do
       assert cascade.cascades?
     end
   end
+
+  describe '#includes?' do
+    let :i18n do
+      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
+    end
+
+    it 'tells you if you have a translation' do
+      assert i18n.includes?('deep')
+      assert i18n.includes?('deep.key')
+      refute i18n.includes?('deep.nope')
+      refute i18n.includes?('nope')
+    end
+
+    it 'allows overriding the locale' do
+      assert i18n.includes?('french', locale: 'fr')
+      assert i18n.includes?('french', locales: %w[en fr])
+      refute i18n.includes?('french', locales: %w[en])
+      refute i18n.includes?('french')
+    end
+
+    it 'allows cascading' do
+      assert i18n.includes?('cascade.nope.tacos', cascade: true)
+      refute i18n.includes?('cascade.nope.tacos', cascade: false)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tater
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Evan Lecklider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-14 00:00:00.000000000 Z
+date: 2020-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -24,6 +24,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 +52,20 @@ dependencies:
     - - ">="
       - !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'
 description: Minimal internationalization and localization library.
 email:
 - evan@lecklider.com
@@ -74,13 +102,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '2.0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Minimal internationalization and localization library.
 test_files:
-- test/fixtures/messages/more.yml
 - test/fixtures/ruby.rb
-- test/fixtures/fixtures.yml
 - test/fixtures/another.yml
+- test/fixtures/fixtures.yml
+- test/fixtures/messages/more.yml
 - test/tater_test.rb