tater 3.0.4 → 3.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1913c7bc9ecb58cbb7ff7c4239978c8401116a954f967e1fd1e557ad30b0e7bd
-  data.tar.gz: cd65a35921e999375affaf4a38717fc14c6938285f3ad1d4258727494a212d40
+  metadata.gz: 18944b6a0817574ffa53d289a770dc0d014f7e6cc2a7288bcea2f759ed317aa4
+  data.tar.gz: 0716a6538423a4722bae9929a4fa7668eeace79517680c1e5c30a9e5a9635a28
 SHA512:
-  metadata.gz: 8744cffa6df1821728ee83f221899d7b5dae739c9420f0ce40bbd02f9b7a7d1388aeed8f54a3d029663a2843b0fca915cd277dc688b044a559c994630695bfc1
-  data.tar.gz: 4e0cfde2f00feaf6e3ce76aec920b0f56a208dfc59e18f0af0c679fe1f8d733ce6c5343bdafc36df33bb2170b6ac660e36d906161273ddf7a3c9fc0a96cf78aa
+  metadata.gz: '0690c57c5f348ace3b92d3156efadb40de9256843b20bd8e0ea36be327f48649e70d7c0baf68abe337d0cd4883a9c6c4690c9f54b5017dd3298bc6fa8b4920eb'
+  data.tar.gz: 91b9b6d51ed90b46b27263d6e911bace16959ea21a8da3aa501bf684acac3fada973c3bf48aec3ef6c0cf67567f7dd5f4494ca5312f23573474c9f71272441ce

data/{README.org → README.md}

@@ -1,39 +1,40 @@
-* Tater
+# Tater
 
-[[https://badge.fury.io/rb/tater][https://badge.fury.io/rb/tater.svg]]
+[![](https://badge.fury.io/rb/tater.svg)](https://badge.fury.io/rb/tater)
+[![](https://github.com/evanleck/tater/actions/workflows/main.yml/badge.svg)](https://github.com/evanleck/tater/actions/workflows/main.yml)
 
 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.
+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
+Tater requires Ruby 2.7 or higher. To install Tater, add this line to your
 application's Gemfile (or gems.rb):
 
-#+begin_src ruby
+``` ruby
 gem 'tater'
-#+end_src
+```
 
 And then execute:
 
-#+begin_src sh
+``` sh
 bundle
-#+end_src
+```
 
 Or install it yourself by running:
 
-#+begin_src sh
+``` sh
 gem install tater
-#+end_src
+```
 
-** Usage
+## Usage
 
-#+begin_src ruby
+``` ruby
 require 'tater'
 
 messages = {
@@ -56,56 +57,56 @@ i18n.translate('some.key') # => 'This here string!'
 
 # Interpolation:
 i18n.translate('interpolated', you: 'world') # => 'Hello world!'
-#+end_src
+```
 
-** Array localization
+## Array localization
 
 Given an array, Tater will do it's best to join the elements of the array into a
 sentence based on how many elements there are.
 
-#+begin_example
+``` example
 en:
   array:
     last_word_connector: ", and "
     two_words_connector: " and "
     words_connector: ", "
-#+end_example
+```
 
-#+begin_src ruby
+``` 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:
 
-#+begin_example
+``` example
 en:
   numeric:
     delimiter: ','
     separator: '.'
-#+end_example
+```
 
 With that, you can do things like this:
 
-#+begin_src ruby
+``` ruby
 i18n.localize(1000.2) # => "1,000.20"
-#+end_src
+```
 
 The separator and delimiter can also be passed in per-call:
 
-#+begin_src ruby
+``` 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
-all of the needed names and abbreviations for days and months. Here's the
+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.
 
-#+begin_example
+``` example
 fr:
   time:
     am: 'am'
@@ -168,27 +169,27 @@ fr:
       - oct.
       - nov.
       - déc.
-#+end_example
+```
 
-The statically defined keys for dates are =days=, =abbreviated_days=, =months=,
-and =abbreviated_months=. Only =am= and =pm= are needed for times and only if
-you plan on using the =%p= or =%P= format strings.
+The statically defined keys for dates are `days`, `abbreviated_days`, `months`,
+and `abbreviated_months`. Only `am` and `pm` are needed for times and only if
+you plan on using the `%p` or `%P` format strings.
 
 With all of that, you can do something like:
 
-#+begin_src ruby
+``` 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
 incrementally.
 
-#+begin_src ruby
+``` ruby
 messages = {
   'en' => {
     'login' => {
@@ -207,40 +208,40 @@ i18n.translate('login.special.title') # => 'Special Login'
 i18n.translate('login.special.description') # => 'Tater lookup failed'
 
 i18n.translate('login.special.description', cascade: true) # => 'Normal description.'
-#+end_src
+```
 
 With cascade, the final key stays the same, but pieces of the scope get lopped
 off. In this case, lookups will be tried in this order:
 
-1. =login.special.description=
-2. =login.description=
+1.  `login.special.description`
+2.  `login.description`
 
 This can be useful when you want to override some messages but don't want to
 have to copy all of the other, non-overwritten messages.
 
 Cascading can also be enabled by default when initializing an instance of Tater.
 
-#+begin_src ruby
+``` 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`.
 
-#+begin_src ruby
+``` 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 evaluated.
 
-#+begin_src ruby
+``` ruby
 {
   'en' => {
     ruby: proc do |key, options = {}|
@@ -248,15 +249,15 @@ Ruby file returns a =Hash= when evalled.
     end
   }
 }
-#+end_src
+```
 
-** Multiple locales
+## Multiple locales
 
 If you would like to check multiple locales and pull the first matching one out,
-you can pass the =:locales= option to initialization or the =translate= method
+you can pass the `:locales` option to initialization or the `translate` method
 with an array of top-level locale keys.
 
-#+begin_src ruby
+``` ruby
 messages = {
   'en' => {
     'title' => 'Login',
@@ -275,23 +276,25 @@ i18n.translate('description', locales: %w[fr en]) # => 'English description.'
 i18n = Tater.new(messages: messages, locales: %w[fr en])
 i18n.translate('title') # => 'la connexion'
 i18n.translate('description') # => 'English description.'
-#+end_src
+```
 
 Locales will be tried in order and whichever one matches first will be returned.
 
-** Limitations
+## Limitations
 
-- It is not pluggable, it does what it does and that's it.
+- It is not plug-able, it does what it does and that's it.
 - It doesn't handle pluralization yet, though it may in the future.
 
-** Why?
+## Why?
 
-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.
+Because [Ruby I18n](https://github.com/ruby-i18n/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.
 
-** Trivia
+## Trivia
 
-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.
+I was originally going to call this library "Translator" but with a
+[numeronym](https://en.wikipedia.org/wiki/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/utils.rb

@@ -52,7 +52,8 @@ class Tater
       end.freeze
     end
 
-    # Format values into a string if appropriate.
+    # Format values into a string, conditionally checking the string and options
+    # before interpolating.
     #
     # @param string [String]
     #   The target string to interpolate into.
@@ -64,6 +65,18 @@ class Tater
       return string if options.empty?
       return string unless interpolation_string?(string)
 
+      interpolate!(string, options)
+    end
+
+    # Format values into a string unconditionally.
+    #
+    # @param string [String]
+    #   The target string to interpolate into.
+    # @param options [Hash]
+    #   The values to interpolate into the target string.
+    #
+    # @return [String]
+    def self.interpolate!(string, options)
       format(string, options)
     end
 

data/lib/tater/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+class Tater
+  VERSION = '3.0.6'
+end

data/lib/tater.rb

@@ -4,8 +4,9 @@ require 'date'
 require 'time'
 require 'yaml'
 
-require 'tater/utils'
 require 'tater/hash' unless Hash.method_defined?(:except)
+require 'tater/utils'
+require 'tater/version'
 
 # Tater is a internationalization (i18n) and localization (l10n) library
 # designed for speed and simplicity.
@@ -22,6 +23,11 @@ class Tater
   # Needed for Ruby < 3.
   using HashExcept unless Hash.method_defined?(:except)
 
+  # An array of the available locale codes found in loaded messages.
+  #
+  # @return [Array<String>]
+  attr_reader :available
+
   # @return [String]
   attr_reader :locale
 
@@ -37,6 +43,8 @@ class Tater
   # @param path [String]
   #   A path to search for YAML or Ruby files to load messages from.
   def initialize(cascade: false, locale: nil, messages: nil, path: nil)
+    @available = []
+    @cache = {}
     @cascade = cascade
     @locale = locale
     @messages = {}
@@ -45,6 +53,11 @@ class Tater
     load(messages: messages) if messages
   end
 
+  # @return [String]
+  def inspect
+    %(#<Tater:#{ object_id } @cascade=#{ @cascade } @locale="#{ @locale }" @available=#{ @available }>)
+  end
+
   # Do lookups cascade by default?
   #
   # @return [Boolean]
@@ -52,13 +65,6 @@ class Tater
     @cascade
   end
 
-  # An array of the available locale codes found in loaded messages.
-  #
-  # @return [Array]
-  def available
-    @available ||= messages.keys
-  end
-
   # Is this locale available in our current set of messages?
   #
   # @return [Boolean]
@@ -89,12 +95,12 @@ class Tater
     @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)
+    # Update our available locales.
+    @available.replace(@messages.keys.map(&:to_s).sort)
 
     # Not only does this clear our cache but it establishes the basic structure
     # that we rely on in other methods.
-    @cache = {}
+    @cache.clear
 
     @messages.each_key do |key|
       @cache[key] = { false => {}, true => {} }
@@ -106,7 +112,8 @@ class Tater
   # @param locale [String]
   #   The locale code to set as our default.
   def locale=(locale)
-    @locale = locale.to_s if available?(locale)
+    str = locale.to_s
+    @locale = str if available?(str)
   end
 
   # Localize an Array, Date, Time, DateTime, or Numeric object.
@@ -210,24 +217,9 @@ class Tater
   #
   # @return [Boolean]
   def includes?(key, options = HASH)
-    if options.empty?
-      !lookup(key).nil?
-    else
-      message =
-        if options.key?(:locales)
-          options[:locales].append(@locale) if @locale && !options[:locales].include?(@locale)
+    return !lookup(key).nil? if options.empty?
 
-          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
+    !lookup_with_options(key, options).nil?
   end
 
   # Translate a key path and optional interpolation arguments into a string.
@@ -257,33 +249,22 @@ class Tater
   #   defined key.
   def translate(key, options = HASH)
     if options.empty?
-      message = lookup(key)
-
-      if message.is_a?(Proc) # rubocop:disable Style/CaseLikeIf
-        message.call(key)
-      elsif message.is_a?(String)
+      case (message = lookup(key))
+      when String
         message
+      when Proc
+        message.call(key)
       else
         "Tater lookup failed: #{ locale }.#{ key }"
       end
     else
-      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
+      case (message = lookup_with_options(key, options))
+      when String
+        return message unless Utils.interpolation_string?(message)
 
-      if message.is_a?(Proc) # rubocop:disable Style/CaseLikeIf
+        Utils.interpolate!(message, options.except(:cascade, :default, :locale, :locales))
+      when Proc
         message.call(key, options.except(:cascade, :default, :locale, :locales))
-      elsif message.is_a?(String)
-        Utils.interpolate(message, options.except(:cascade, :default, :locale, :locales))
       else
         options[:default] || "Tater lookup failed: #{ options[:locale] || options[:locales] || locale }.#{ key }"
       end
@@ -292,6 +273,28 @@ class Tater
 
   private
 
+  # @param key [String]
+  #   The period-separated key path to look within our messages for.
+  # @param options [Hash]
+  #   Options, including values to interpolate to any found string.
+  #
+  # @return [String]
+  #   The translated and interpreted string, if found, or any data at the
+  #   defined key.
+  def lookup_with_options(key, options)
+    if (locs = options[:locales])
+      locs.append(@locale) if @locale && !locs.include?(@locale)
+
+      locs.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
+  end
+
   # Localize an Array object.
   #
   # @param object [Array<String>]

metadata

@@ -1,127 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: tater
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.0.6
 platform: ruby
 authors:
 - Evan Lecklider
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-22 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
-    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: 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
-    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-minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-packaging
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    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'
+date: 2023-05-26 00:00:00.000000000 Z
+dependencies: []
 description: Minimal internationalization and localization library.
 email:
 - evan@lecklider.com
@@ -130,21 +18,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
-- README.org
+- README.md
 - lib/tater.rb
 - lib/tater/aliases.rb
 - lib/tater/hash.rb
 - lib/tater/utils.rb
-- test/fixtures/another.yml
-- test/fixtures/fixtures.yml
-- test/fixtures/messages/more.yml
-- test/fixtures/ruby.rb
-- test/tater_test.rb
+- lib/tater/version.rb
 homepage: https://github.com/evanleck/tater
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/evanleck/tater/issues
+  changelog_uri: https://github.com/evanleck/tater/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/evanleck/tater
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/evanleck/tater
 post_install_message:
@@ -155,20 +41,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.10
 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/tater_test.rb
+test_files: []

data/test/fixtures/another.yml

@@ -1,2 +0,0 @@
-en:
-  another: 'This is from a different file'

data/test/fixtures/fixtures.yml

@@ -1,102 +0,0 @@
-en:
-  english: 'Found in English'
-
-  title: 'This is a title'
-  interpolated: 'This has some %{fancy} text'
-  double: '%{first} %{second}!'
-
-  deep:
-    key: 'This key is deeper'
-
-  array:
-    last_word_connector: ", and "
-    two_words_connector: " and "
-    words_connector: ", "
-
-  date:
-    formats:
-      default: '%Y/%-m/%-d'
-      ohmy: '%-m something %-d oh my %Y'
-
-  time:
-    formats:
-      default: '%Y/%-m/%-d/%H/%M/%S'
-
-  datetime:
-    formats:
-      default: '%Y/%-m/%-d/%H/%M/%S'
-
-  numeric:
-    delimiter: 'TURKEYS'
-    separator: 'NAH'
-
-  cascade:
-    tacos: 'Delicious'
-
-    another:
-      crazy: 'Whoaa'
-
-fr:
-  french: 'Found in French'
-
-  time:
-    am: 'am'
-    pm: 'pm'
-
-    formats:
-      default: '%I%P'
-      loud: '%I%p'
-
-  date:
-    formats:
-      abbreviated_day: '%a'
-      day: '%A'
-
-      abbreviated_month: '%b'
-      month: '%B'
-
-    days:
-      - dimanche
-      - lundi
-      - mardi
-      - mercredi
-      - jeudi
-      - vendredi
-      - samedi
-
-    abbreviated_days:
-      - dim
-      - lun
-      - mar
-      - mer
-      - jeu
-      - ven
-      - sam
-
-    months:
-      - janvier
-      - février
-      - mars
-      - avril
-      - mai
-      - juin
-      - juillet
-      - août
-      - septembre
-      - octobre
-      - novembre
-      - décembre
-
-    abbreviated_months:
-      - jan.
-      - fév.
-      - mar.
-      - avr.
-      - mai
-      - juin
-      - juil.
-      - août
-      - sept.
-      - oct.
-      - nov.
-      - déc.

data/test/fixtures/messages/more.yml

@@ -1,12 +0,0 @@
-en:
-  more: "Oh there's more!"
-
-delimiter_only:
-  numeric:
-    formats:
-      delimiter: 'Just me'
-
-separator_only:
-  numeric:
-    formats:
-      separator: 'Just me'

data/test/fixtures/ruby.rb

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

data/test/tater_test.rb

@@ -1,458 +0,0 @@
-# frozen_string_literal: true
-$LOAD_PATH.unshift File.expand_path('lib', __dir__)
-
-require 'date'
-require 'minitest/autorun'
-require 'tater'
-
-describe Tater do
-  describe Tater::Utils 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' } }
-
-        third = Tater::Utils.deep_merge(first, second)
-
-        assert_equal({ 'one' => 'one', 'two' => { 'three' => 'three', 'four' => 'four' } }, third)
-      end
-    end
-
-    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)
-
-        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 finish.frozen?
-        assert finish.keys.all?(&:frozen?)
-        assert finish.values.all?(&:frozen?)
-      end
-    end
-
-    describe '#interpolate' do
-      it 'interpolates a string and hash' do
-        assert_equal 'this thing', Tater::Utils.interpolate('this %{what}', what: 'thing')
-      end
-
-      it 'raises a KeyError when an argument is missing (but options are passed)' do
-        assert_raises(KeyError) do
-          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'))
-      end
-    end
-
-    describe '#interpolation_string?' do
-      def is?(arg)
-        Tater::Utils.interpolation_string?(arg)
-      end
-
-      it 'checks whether a string contains interpolation placeholders' do
-        assert is?('Hey %{there}!')
-        assert is?('Hey %<there>s!')
-        refute is?('Nah, this is fine')
-        refute is?("<b>HTML shouldn't count")
-        refute is?("A single % shouldn't count")
-      end
-    end
-  end
-
-  describe '#available?' do
-    let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
-    end
-
-    it 'tells you if the locale is available' do
-      assert i18n.available?('en')
-      refute i18n.available?('romulan')
-    end
-  end
-
-  describe '#load' do
-    it 'loads from a path on initialization' do
-      i18n = Tater.new(path: File.expand_path('test/fixtures'))
-
-      assert_instance_of(Hash, i18n.messages)
-    end
-
-    it 'loads from a path after initialization' do
-      i18n = Tater.new
-      i18n.load(path: File.expand_path('test/fixtures'))
-
-      assert_instance_of(Hash, i18n.messages)
-    end
-
-    it 'loads from a hash of messages on initialization' do
-      i18n = Tater.new(messages: { 'hey' => 'Oh hi' })
-
-      assert_instance_of(Hash, i18n.messages)
-    end
-
-    it 'loads from a hash of messages after initialization' do
-      i18n = Tater.new
-      i18n.load(messages: { 'hey' => 'Oh hi' })
-
-      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
-    let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'))
-    end
-
-    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'), locale: 'en')
-    end
-
-    it 'returns keys from messages' do
-      assert_equal 'This is a title', i18n.lookup('title')
-    end
-
-    it 'does no interpolation' do
-      assert_equal 'This has some %{fancy} text', i18n.lookup('interpolated')
-    end
-
-    it 'returns nil for missing lookups' do
-      assert_nil i18n.lookup('nope')
-    end
-
-    it 'returns arbitrary data at keys' do
-      assert_equal({ 'key' => 'This key is deeper' }, i18n.lookup('deep'))
-    end
-
-    it 'cascades' do
-      assert_equal 'Delicious', i18n.lookup('cascade.nope.tacos', cascade: true)
-      assert_equal 'Whoaa', i18n.lookup('cascade.another.nope.crazy', cascade: true)
-      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'), locale: 'en')
-    end
-
-    it 'translates strings' do
-      assert_equal 'This is a title', i18n.translate('title')
-    end
-
-    it 'translates nested strings' do
-      assert_equal 'This key is deeper', i18n.translate('deep.key')
-    end
-
-    it 'does not return a hash for nested keys' do
-      assert_equal 'Tater lookup failed: en.deep', i18n.translate('deep')
-    end
-
-    it 'interpolates additional variables' do
-      assert_equal 'This has some fancy text', i18n.translate('interpolated', fancy: 'fancy')
-      assert_equal 'Double down!', i18n.translate('double', first: 'Double', second: 'down')
-    end
-
-    it 'works with multiple files' do
-      assert_equal 'This is from a different file', i18n.translate('another')
-      assert_equal "Oh there's more!", i18n.translate('more')
-    end
-
-    it 'returns a message for failed translations' do
-      assert_equal 'Tater lookup failed: en.nope', i18n.translate('nope')
-    end
-
-    it 'cascades lookups' do
-      assert_equal 'Tater lookup failed: en.cascade.another.nope.crazy', i18n.translate('cascade.another.nope.crazy', cascade: false)
-      assert_equal 'Tater lookup failed: en.cascade.nope.tacos', i18n.translate('cascade.nope.tacos')
-      assert_equal 'Delicious', i18n.translate('cascade.nope.tacos', cascade: true)
-    end
-
-    it 'defaults lookups' do
-      assert_equal 'Tater lookup failed: en.default.missing', i18n.translate('default.missing')
-      assert_equal 'Nope', i18n.translate('default.missing', default: 'Nope')
-    end
-
-    it 'does lookups across different locales' do
-      assert_equal 'Found in French', i18n.translate('french', locales: %w[fr en])
-      assert_equal 'Found in English', i18n.translate('english', locales: %w[fr en])
-      assert_equal 'Tater lookup failed: ["fr", "en"].neither', i18n.translate('neither', locales: %w[fr en])
-    end
-
-    it 'finds Ruby files' do
-      assert_equal 'Hey ruby!', i18n.translate('ruby')
-    end
-
-    it 'does not interpolate messages returned by procs' do
-      assert_equal 'Hey %{options}!', i18n.translate('options', options: 'options')
-    end
-  end
-
-  describe '#localize' do
-    let :i18n do
-      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
-      assert_equal '1970/1/1', i18n.localize(Date.new(1970, 1, 1))
-    end
-
-    it 'localizes Times' do
-      assert_equal '1970/1/1/00/00/00', i18n.localize(Time.new(1970, 1, 1, 0, 0, 0))
-    end
-
-    it 'localizes DateTimes' do
-      assert_equal '1970/1/1/00/00/00', i18n.localize(DateTime.new(1970, 1, 1, 0, 0, 0))
-    end
-
-    it 'localizes Floats' do
-      assert_equal '10TURKEYS000NAH12', i18n.localize(10_000.12)
-    end
-
-    it 'localizes Integers' do
-      assert_equal '10TURKEYS000', i18n.localize(10_000)
-    end
-
-    it 'localizes BigDecimals' 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')
-    end
-
-    it 'accepts other formats' do
-      assert_equal '1 something 1 oh my 1970', i18n.localize(Date.new(1970, 1, 1), format: 'ohmy')
-    end
-
-    it 'uses the passed in format if the specified class and format are not present' do
-      assert_equal 'not there', i18n.localize(Date.new(1970, 1, 1), format: 'not there')
-    end
-
-    it 'raises a MissingLocalizationFormat if a delimiter is missing' do
-      assert_raises(Tater::MissingLocalizationFormat) do
-        i18n.localize(10, locale: 'separator_only')
-      end
-    end
-
-    it 'raises a MissingLocalizationFormat if a separator is missing' do
-      assert_raises(Tater::MissingLocalizationFormat) do
-        i18n.localize(10, locale: 'delimiter_only')
-      end
-    end
-
-    describe 'month, day, and AM/PM names' do
-      let :i18n do
-        Tater.new(path: File.expand_path('test/fixtures'), locale: 'fr')
-      end
-
-      it 'localizes day names' do
-        assert_equal 'jeudi', i18n.localize(Date.new(1970, 1, 1), format: 'day')
-        assert_equal 'vendredi', i18n.localize(Date.new(1970, 1, 2), format: 'day')
-        assert_equal 'samedi', i18n.localize(Date.new(1970, 1, 3), format: 'day')
-        assert_equal 'dimanche', i18n.localize(Date.new(1970, 1, 4), format: 'day')
-        assert_equal 'lundi', i18n.localize(Date.new(1970, 1, 5), format: 'day')
-        assert_equal 'mardi', i18n.localize(Date.new(1970, 1, 6), format: 'day')
-        assert_equal 'mercredi', i18n.localize(Date.new(1970, 1, 7), format: 'day')
-      end
-
-      it 'localizes abbreviated day names' do
-        assert_equal 'jeu', i18n.localize(Date.new(1970, 1, 1), format: 'abbreviated_day')
-        assert_equal 'ven', i18n.localize(Date.new(1970, 1, 2), format: 'abbreviated_day')
-        assert_equal 'sam', i18n.localize(Date.new(1970, 1, 3), format: 'abbreviated_day')
-        assert_equal 'dim', i18n.localize(Date.new(1970, 1, 4), format: 'abbreviated_day')
-        assert_equal 'lun', i18n.localize(Date.new(1970, 1, 5), format: 'abbreviated_day')
-        assert_equal 'mar', i18n.localize(Date.new(1970, 1, 6), format: 'abbreviated_day')
-        assert_equal 'mer', i18n.localize(Date.new(1970, 1, 7), format: 'abbreviated_day')
-      end
-
-      it 'localizes months' do
-        assert_equal 'janvier', i18n.localize(Date.new(1970, 1, 1), format: 'month')
-        assert_equal 'février', i18n.localize(Date.new(1970, 2, 1), format: 'month')
-        assert_equal 'mars', i18n.localize(Date.new(1970, 3, 1), format: 'month')
-        assert_equal 'avril', i18n.localize(Date.new(1970, 4, 1), format: 'month')
-        assert_equal 'mai', i18n.localize(Date.new(1970, 5, 1), format: 'month')
-        assert_equal 'juin', i18n.localize(Date.new(1970, 6, 1), format: 'month')
-        assert_equal 'juillet', i18n.localize(Date.new(1970, 7, 1), format: 'month')
-        assert_equal 'août', i18n.localize(Date.new(1970, 8, 1), format: 'month')
-        assert_equal 'septembre', i18n.localize(Date.new(1970, 9, 1), format: 'month')
-        assert_equal 'octobre', i18n.localize(Date.new(1970, 10, 1), format: 'month')
-        assert_equal 'novembre', i18n.localize(Date.new(1970, 11, 1), format: 'month')
-        assert_equal 'décembre', i18n.localize(Date.new(1970, 12, 1), format: 'month')
-      end
-
-      it 'localizes abbreviated months' do
-        assert_equal 'jan.', i18n.localize(Date.new(1970, 1, 1), format: 'abbreviated_month')
-        assert_equal 'fév.', i18n.localize(Date.new(1970, 2, 1), format: 'abbreviated_month')
-        assert_equal 'mar.', i18n.localize(Date.new(1970, 3, 1), format: 'abbreviated_month')
-        assert_equal 'avr.', i18n.localize(Date.new(1970, 4, 1), format: 'abbreviated_month')
-        assert_equal 'mai', i18n.localize(Date.new(1970, 5, 1), format: 'abbreviated_month')
-        assert_equal 'juin', i18n.localize(Date.new(1970, 6, 1), format: 'abbreviated_month')
-        assert_equal 'juil.', i18n.localize(Date.new(1970, 7, 1), format: 'abbreviated_month')
-        assert_equal 'août', i18n.localize(Date.new(1970, 8, 1), format: 'abbreviated_month')
-        assert_equal 'sept.', i18n.localize(Date.new(1970, 9, 1), format: 'abbreviated_month')
-        assert_equal 'oct.', i18n.localize(Date.new(1970, 10, 1), format: 'abbreviated_month')
-        assert_equal 'nov.', i18n.localize(Date.new(1970, 11, 1), format: 'abbreviated_month')
-        assert_equal 'déc.', i18n.localize(Date.new(1970, 12, 1), format: 'abbreviated_month')
-      end
-
-      it 'localizes AM/PM' do
-        assert_equal '05pm', i18n.localize(Time.new(1970, 1, 1, 17))
-        assert_equal '05PM', i18n.localize(Time.new(1970, 1, 1, 17), format: 'loud')
-        assert_equal '05am', i18n.localize(Time.new(1970, 1, 1, 5))
-        assert_equal '05AM', i18n.localize(Time.new(1970, 1, 1, 5), format: 'loud')
-      end
-    end
-  end
-
-  describe '#locale=' do
-    let :i18n do
-      Tater.new(path: File.expand_path('test/fixtures'), locale: 'en')
-    end
-
-    it 'overrides the locale when available' do
-      i18n.locale = 'delimiter_only'
-      assert_equal 'delimiter_only', i18n.locale
-    end
-
-    it 'does not override the locale when not available' do
-      i18n.locale = 'nopeskies'
-      assert_equal 'en', i18n.locale
-    end
-  end
-
-  describe '#cascades?' do
-    let :default do
-      Tater.new
-    end
-
-    let :cascade do
-      Tater.new(cascade: true)
-    end
-
-    it 'returns false by default' do
-      refute default.cascades?
-    end
-
-    it 'returns true when passed during initialization' 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