tater 1.3.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d41ee7aa6cc55a97ad00ee6b96ccbb6127344f9b3e85c4cf3b162f72f3d115d8
-  data.tar.gz: 2fe1b6c5aff5fdfcc48dbd8212ddbbf0903f9af071c42ff1178c1f20752f536a
+  metadata.gz: 16fddfa1cedd9af51e3d2e04422a083a16ee055e1102ad4482bfb28beee3be78
+  data.tar.gz: 73273faf3a6bb5842d6adc2854ca98e81363efd0c45835de07fc2e4d807effa2
 SHA512:
-  metadata.gz: d686b81192264e1f78f17c0decf0ac3811582e0fe464d2f5f44281481351abca8bd3906fe218a2ae9309a3d84177382f5de7348f63ae3967b7d2af2dc452bcb6
-  data.tar.gz: 942fd8b6a433b65778f3d7a78f07a8d99c902c5483eec105e0c75689d40db7d0664170963e514d5e78928450b6c0499dce8c3afd63f0eaded6d9843cf3e703a8
+  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!'
 
@@ -57,7 +62,7 @@ i18n.translate('interpolated', you: 'world') # => 'Hello world!'
 ```
 
 
-## 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.
@@ -75,7 +80,7 @@ i18n.localize(%w[tacos enchiladas burritos]) # => "tacos, enchiladas, and burrit
 ```
 
 
-## Numeric Localization
+## Numeric localization
 
 Numeric localization (`Numeric`, `Integer`, `Float`, and `BigDecimal`) require
 filling in a separator and delimiter. For example:
@@ -100,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
@@ -185,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'
 
@@ -237,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
@@ -253,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 = {
@@ -272,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,7 +63,7 @@ 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?
 
@@ -72,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
 
@@ -83,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 = {}
@@ -99,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?
@@ -114,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))) # rubocop:disable Security/Eval
+        @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.
@@ -144,7 +179,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.
@@ -167,17 +202,14 @@ 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
@@ -194,23 +226,22 @@ 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
 
@@ -222,14 +253,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
@@ -245,26 +276,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
 
-    if cascade_override.nil? ? @cascade : cascade_override
-      while path.length >= 2
-        attempt = @messages.dig(*path)
+    cached(key, locale, cascade) || begin
+      return nil unless @messages.key?(locale.to_s)
 
-        break attempt if attempt
+      path = key.split(SEPARATOR).prepend(locale).map(&:to_s)
 
-        path.delete_at(path.length - 2)
-      end
-    else
-      @messages.dig(*path)
+      message =
+        if cascade
+          while path.length >= 2
+            attempt = @messages.dig(*path)
+
+            break attempt unless attempt.nil?
+
+            path.delete_at(path.length - 2)
+          end
+        else
+          @messages.dig(*path)
+        end
+
+      cache(key, locale, cascade, message)
     end
   end
 
@@ -284,20 +325,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)
 
-          break found if found
+        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?
@@ -307,7 +346,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.
@@ -319,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/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
 
@@ -46,14 +56,14 @@ describe Tater 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
@@ -88,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
@@ -98,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
@@ -118,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
@@ -185,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
@@ -336,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
@@ -370,7 +394,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tater
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Evan Lecklider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-06 00:00:00.000000000 Z
+date: 2020-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest