tater 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '04904502e539d0ef7eab036d0a3b6c22a635863cdc76e56b27648c9d1005e12c'
+  data.tar.gz: 1ab472fa93cff9180ed718bc54a1209a2151c7a7be77f5ed045047a5865bdfa3
+SHA512:
+  metadata.gz: 1faf70fb545ce2e0d2211f9af52830421c13f331e0b0519fe1c92b2e9443e1230c5c63ea19c4660d4f8468da4572b304022c8a7d93bf2aa9862b6cbb0e55cd08
+  data.tar.gz: e87befcdfd969ebbce3350c1427070099224bfa24b4cafaafe246b0c1e3917d0e64d09fa5c1fca06678170f6411ffe548b7c3363888ab56061d16ab98657a8ae

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Evan Lecklider
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+# Tater the Translator
+
+Tater is an internationalization (i18n) and localization (l10n) library designed
+for simplicity. It doesn't do everything that other libraries do, but that's by
+design.
+
+Under the hood, Tater uses a Hash to store the messages, the `dig` method for
+lookups, `strftime` for date and time localizations, and `format` for
+interpolation. That's probably 90% of what Tater does.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tater'
+```
+
+And then execute:
+
+```sh
+bundle
+```
+
+Or install it yourself as:
+
+```sh
+gem install tater
+```
+
+
+## Usage
+
+```ruby
+messages = {
+  'some' => {
+    'key' => 'This here string!'
+  },
+  'interpolated' => 'Hello %{you}!'
+}
+
+i18n = Tater.new
+i18n.load(messages: messages)
+
+# Basic lookup:
+i18n.translate('some.key') # => 'This here string!'
+
+# Interpolation:
+i18n.translate('interpolated', you: 'world') # => 'Hello world!'
+```
+
+## Numeric Localization
+
+Numeric localization (`Numeric`, `Integer`, `Float`, and `BigDecimal`) require
+filling in a separater and delimiter. For example:
+
+```yaml
+en:
+  numeric:
+    delimiter: ','
+    separator: '.'
+```
+
+With that, you can do things like this:
+
+```ruby
+i18n.localize(1000.2) # => "1,000.20"
+```
+
+
+## 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
+example for French, which is used in the tests.
+
+```yaml
+fr:
+  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.
+```
+
+The statically defined keys for dates are `days`, `abbreviated_days`, `months`,
+and `abbreviated_months`. Only `am` and `pm` are needed for times and only if
+you plan on using the `%p` or `%P` format strings.
+
+With all of that, you can do something like:
+
+```ruby
+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'
+```
+
+
+## Limitations
+
+- It is not "pluggable", it does what it does and that's it.
+- It doesn't handle pluralization yet, though it may in the future.
+- It doesn't cache anything, that's up to you.
+
+
+## Why?
+
+Because [Ruby I18n][rubyi18n] is amazing and I wanted to try to create a minimum
+viable implementation of the bits of I18n that I use 90% of the time. Tater is a
+single file that handles the basics of lookup and interpolation.
+
+
+## Trivia
+
+I was orininally going to call this library "Translator" but with a
+[numeronym][numeronym] like I18n: "t8r". I looked at it for a while but I read
+it as "tater" instead of "tee-eight-arr" so I figured I'd just name it Tater.
+Tater the translator.
+
+[numeronym]: https://en.wikipedia.org/wiki/Numeronym
+[rubyi18n]: https://github.com/ruby-i18n/i18n

data/lib/tater.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+require 'bigdecimal'
+require 'yaml'
+
+# Tater is a internationalization (i18n) and localization (l10n) library
+# designed for speed and simplicity.
+class Tater
+  class MissingLocalizationFormat < ArgumentError; end
+  class UnLocalizableObject < ArgumentError; end
+
+  module Utils # :nodoc:
+    # Merge all the way down.
+    #
+    # @param to [Hash]
+    #   The target Hash to merge into. Note that modification is done in-place,
+    #   not on a copy of the object.
+    # @param from [Hash]
+    #   The Hash to copy values from.
+    def self.deep_merge!(to, from)
+      to.merge!(from) do |_key, left, right|
+        if left.is_a?(Hash) && right.is_a?(Hash)
+          Utils.deep_merge!(left, right)
+        else
+          right
+        end
+      end
+    end
+
+    # Transform keys all the way down.
+    #
+    # @param hash [Hash]
+    #   The Hash to 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|
+        if value.is_a?(Hash)
+          Utils.deep_stringify_keys!(value)
+        else
+          value
+        end
+      end
+    end
+
+    # Try to interpolate these things, if one of them is a string.
+    #
+    # @param string [String]
+    #   The target string to interpolate into.
+    # @param options [Hash]
+    #   The values to interpolate into the target string.
+    #
+    # @return [String]
+    def self.interpolate(string, options = {})
+      return string unless string.is_a?(String)
+
+      format(string, options)
+    end
+
+    # Convert a Numeric to a string, particularly formatting BigDecimals to a
+    # Float-like string representation.
+    #
+    # @param numeric [Numeric]
+    #
+    # @return [String]
+    def self.string_from_numeric(numeric)
+      if numeric.is_a?(BigDecimal)
+        numeric.to_s('F')
+      else
+        numeric.to_s
+      end
+    end
+  end
+
+  DEFAULT = 'default'
+  DEFAULT_LOCALE = 'en'
+  DELIMITING_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/.freeze
+  SEPARATOR = '.'
+  SUBSTITUTION_REGEX = /%(|\^)[aAbBpP]/.freeze
+
+  # @return [String]
+  attr_reader :locale
+
+  # @return [Hash]
+  attr_reader :messages
+
+  def initialize(path: nil, messages: nil, locale: DEFAULT_LOCALE)
+    @locale = locale
+    @messages = {}
+
+    load(path: path) if path
+    load(messages: messages) if messages
+  end
+
+  # An array of the available locale codes.
+  #
+  # @return [Array]
+  def available
+    messages.keys.map(&:to_s)
+  end
+
+  # Is this locale available in our current set of messages?
+  #
+  # @return [Boolean]
+  def available?(locale)
+    available.include?(locale.to_s)
+  end
+
+  # Load messages into our internal cache, either from a path containing YAML
+  # files or a collection of messages.
+  #
+  # @param path [String]
+  #   A path to search for YAML files to load messages from.
+  # @param messages [Hash]
+  #   A hash of messages ready to be loaded in.
+  def load(path: nil, messages: nil)
+    if path
+      Dir.glob(File.join(path, '**', '*.{yml,yaml}')).each do |file|
+        Utils.deep_merge!(@messages, YAML.safe_load(File.read(file)))
+      end
+    end
+
+    Utils.deep_merge!(@messages, Utils.deep_stringify_keys!(messages)) if messages
+  end
+
+  # Set the current locale, if it's available.
+  #
+  # @param locale [String]
+  #   The locale code to set as our default.
+  def locale=(locale)
+    @locale = locale.to_s if available?(locale)
+  end
+
+  # Localize a Date, Time, DateTime, or Numeric object.
+  #
+  # @param object [Date, Time, DateTime, Numeric]
+  #   The object to localize.
+  #
+  # @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)
+
+    case object
+    when String
+      object
+    when Numeric
+      delimiter = lookup('numeric.delimiter', locale_override)
+      separator = lookup('numeric.separator', locale_override)
+      precision = options.fetch(:precision) { 2 }
+
+      raise(MissingLocalizationFormat, "Numeric localization delimiter ('numeric.delimiter') missing") unless delimiter
+      raise(MissingLocalizationFormat, "Numeric localization separator ('numeric.separator') missing") unless separator
+
+      # Heavily cribbed from Rails.
+      integer, fraction = Utils.string_from_numeric(object).split('.')
+      integer.gsub!(DELIMITING_REGEX) do |number|
+        "#{ number }#{ delimiter }"
+      end
+
+      if precision.zero?
+        integer
+      else
+        [integer, fraction&.ljust(precision, '0')].compact.join(separator)
+      end
+    when Date, Time, DateTime
+      key = object.class.to_s.downcase
+      format = lookup("#{ key }.formats.#{ format_key }", locale_override) || format_key
+
+      # 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 Metric/BlockNesting
+        when '%P'  then lookup("time.#{ object.hour < 12 ? 'am' : 'pm' }", locale_override).downcase if object.respond_to?(:hour) # rubocop:disable Metric/BlockNesting
+        end
+      end
+
+      object.strftime(format)
+    else
+      raise(UnLocalizableObject, "The object class #{ object.class } cannot be localized by Tater.")
+    end
+  end
+  alias l localize
+
+  # Lookup a key in the messages hash, using the current locale or an override.
+  #
+  # @param key [String]
+  # @param locale_override [String]
+  #   A locale to use instead of our current one.
+  #
+  # @return
+  #   Basically anything that can be stored in YAML, including nil.
+  def lookup(key, locale_override = nil)
+    path = key.split(SEPARATOR).prepend(locale_override || locale).map(&:to_s)
+
+    @messages.dig(*path)
+  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'
+  #
+  # @param key [String]
+  #   The period-separated key path to look within our messages for.
+  #
+  # @return [String]
+  #   The translated and interpreted string, if found, or any data at the
+  #   defined key.
+  def translate(key, options = {})
+    locale_override = options.delete(:locale)
+
+    Utils.interpolate(lookup(key, locale_override), options) || "Tater lookup failed: #{ locale_override || locale }.#{ key }"
+  end
+  alias t translate
+end

data/test/another.yml

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

data/test/fixtures.yml

@@ -0,0 +1,87 @@
+en:
+  title: 'This is a title'
+  interpolated: 'This has some %{fancy} text'
+  double: '%{first} %{second}!'
+
+  deep:
+    key: 'This key is deeper'
+
+  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'
+
+fr:
+  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/messages/more.yml

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

data/test/tater_test.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+require_relative '../lib/tater'
+require 'minitest/autorun'
+require 'date'
+
+describe Tater do
+  describe Tater::Utils do
+    describe '#deep_merge!' do
+      it 'deeply merges two hashes, modifying the first' do
+        first = { 'one' => 'one', 'two' => { 'three' => 'three' } }
+        second = { 'two' => { 'four' => 'four' } }
+
+        Tater::Utils.deep_merge!(first, second)
+
+        assert_equal({ 'one' => 'one', 'two' => { 'three' => 'three', 'four' => 'four' } }, first)
+      end
+    end
+
+    describe '#deep_stringify_keys!' do
+      it 'converts all keys into strings, recursively modifying the hash passed in' do
+        start = { en: { login: { title: 'Hello!' } } }
+
+        Tater::Utils.deep_stringify_keys!(start)
+
+        assert_equal({ 'en' => { 'login' => { 'title' => 'Hello!' } } }, start)
+      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' do
+        assert_raises(KeyError) do
+          Tater::Utils.interpolate('this %{what}')
+        end
+      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
+  end
+
+  describe '#available?' do
+    let :i18n do
+      Tater.new(path: File.expand_path('test'))
+    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'))
+
+      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'))
+
+      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
+  end
+
+  describe '#available' do
+    let :i18n do
+      Tater.new(path: File.expand_path('test'))
+    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], i18n.available
+    end
+  end
+
+  describe '#lookup' do
+    let :i18n do
+      Tater.new(path: File.expand_path('test'))
+    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
+  end
+
+  describe '#translate' do
+    let :i18n do
+      Tater.new(path: File.expand_path('test'))
+    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 'returns a hash for nested keys' do
+      assert_equal({ 'key' => 'This key is deeper' }, 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 'is aliased as t' do
+      assert_equal 'This is a title', i18n.t('title')
+    end
+  end
+
+  describe '#localize' do
+    let :i18n do
+      Tater.new(path: File.expand_path('test'))
+    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
+
+    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
+
+    it 'is aliased l' do
+      assert_equal '1970/1/1', i18n.l(Date.new(1970, 1, 1))
+    end
+
+    describe 'month, day, and AM/PM names' do
+      let :i18n do
+        Tater.new(path: File.expand_path('test'), 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'))
+    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
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: tater
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Evan Lecklider
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-16 00:00:00.000000000 Z
+dependencies:
+- !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: 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'
+description: Minimal internationalization and localization library.
+email:
+- evan@lecklider.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/tater.rb
+- test/another.yml
+- test/fixtures.yml
+- test/messages/more.yml
+- test/tater_test.rb
+homepage: https://github.com/evanleck/tater
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/evanleck/tater/issues
+  source_code_uri: https://github.com/evanleck/tater
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Minimal internationalization and localization library.
+test_files:
+- test/messages/more.yml
+- test/fixtures.yml
+- test/tater_test.rb
+- test/another.yml