honeybadger 5.4.0 → 5.4.1

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/spec/hashdiff/patch_spec.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is able to patch key addition' do
-    a = { 'a' => 3, 'c' => 11, 'd' => 45, 'e' => 100, 'f' => 200 }
-    b = { 'a' => 3, 'c' => 11, 'd' => 45, 'e' => 100, 'f' => 200, 'g' => 300 }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 3, 'c' => 11, 'd' => 45, 'e' => 100, 'f' => 200 }
-    b = { 'a' => 3, 'c' => 11, 'd' => 45, 'e' => 100, 'f' => 200, 'g' => 300 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value type changes' do
-    a = { 'a' => 3 }
-    b = { 'a' => { 'a1' => 1, 'a2' => 2 } }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 3 }
-    b = { 'a' => { 'a1' => 1, 'a2' => 2 } }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value array <=> []' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => [] }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => [] }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value array <=> nil' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => nil }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1, 'b' => nil }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch array value removal' do
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1 }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => [1, 2] }
-    b = { 'a' => 1 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch array under hash key with non-word characters' do
-    a = { 'a' => 1, 'b-b' => [1, 2] }
-    b = { 'a' => 1, 'b-b' => [2, 1] }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b-b' => [1, 2] }
-    b = { 'a' => 1, 'b-b' => [2, 1] }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch hash value removal' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1 }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value hash <=> {}' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => {} }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => {} }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value hash <=> nil' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => nil }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => nil }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch value nil removal' do
-    a = { 'a' => 1, 'b' => nil }
-    b = { 'a' => 1 }
-    diff = described_class.diff(a, b)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => nil }
-    b = { 'a' => 1 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch similar objects between arrays' do
-    a = [{ 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }, 3]
-    b = [1, { 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5 }]
-
-    diff = described_class.diff(a, b)
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = [{ 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }, 3]
-    b = [1, { 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5 }]
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch similar & equal objects between arrays' do
-    a = [{ 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }, { 'x' => 5, 'y' => 6, 'z' => 3 }, 1]
-    b = [1, { 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5 }]
-
-    diff = described_class.diff(a, b)
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = [{ 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }, { 'x' => 5, 'y' => 6, 'z' => 3 }, 1]
-    b = [1, { 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5 }]
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to patch hash value removal with custom delimiter' do
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => { 'b1' => 3 } }
-    diff = described_class.diff(a, b, delimiter: "\n")
-
-    expect(described_class.patch!(a, diff, delimiter: "\n")).to eq(b)
-
-    a = { 'a' => 1, 'b' => { 'b1' => 1, 'b2' => 2 } }
-    b = { 'a' => 1, 'b' => { 'b1' => 3 } }
-    described_class.unpatch!(b, diff, delimiter: "\n").should == a
-  end
-
-  it 'is able to patch when the diff is generated with an array_path' do
-    a = { 'a' => 1, 'b' => 1 }
-    b = { 'a' => 1, 'b' => 2 }
-    diff = described_class.diff(a, b, array_path: true)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, 'b' => 1 }
-    b = { 'a' => 1, 'b' => 2 }
-    described_class.unpatch!(b, diff).should == a
-  end
-
-  it 'is able to use non string keys when diff is generated with an array_path' do
-    a = { 'a' => 1, :a => 2, 0 => 3 }
-    b = { 'a' => 5, :a => 6, 0 => 7 }
-    diff = described_class.diff(a, b, array_path: true)
-
-    expect(described_class.patch!(a, diff)).to eq(b)
-
-    a = { 'a' => 1, :a => 2, 0 => 3 }
-    b = { 'a' => 5, :a => 6, 0 => 7 }
-    described_class.unpatch!(b, diff).should == a
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/spec/hashdiff/readme_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'README.md' do
-  it 'has correct examples' do
-    File.read('README.md').scan(/```ruby(.*?)```/m).flatten(1).each do |block|
-      begin
-        eval block # rubocop:disable Security/Eval
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        raise "README.md code block:\n#{block}\n\nhas error:\n#{e}"
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/spec/hashdiff/util_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Hashdiff do
-  it 'is able to decode property path' do
-    decoded = described_class.send(:decode_property_path, 'a.b[0].c.city[5]')
-    decoded.should == ['a', 'b', 0, 'c', 'city', 5]
-  end
-
-  it 'is able to decode property path with custom delimiter' do
-    decoded = described_class.send(:decode_property_path, "a\tb[0]\tc\tcity[5]", "\t")
-    decoded.should == ['a', 'b', 0, 'c', 'city', 5]
-  end
-
-  it 'is able to tell similiar hash' do
-    a = { 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }
-    b = { 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5 }
-    described_class.similar?(a, b).should be true
-    described_class.similar?(a, b, similarity: 1).should be false
-  end
-
-  it 'is able to tell similiar empty hash' do
-    described_class.similar?({}, {}, similarity: 1).should be true
-  end
-
-  it 'is able to tell similiar empty array' do
-    described_class.similar?([], [], similarity: 1).should be true
-  end
-
-  it 'is able to tell similiar hash with values within tolerance' do
-    a = { 'a' => 1.5, 'b' => 2.25, 'c' => 3, 'd' => 4, 'e' => 5 }
-    b = { 'a' => 1.503, 'b' => 2.22, 'c' => 3, 'e' => 5 }
-    described_class.similar?(a, b, numeric_tolerance: 0.05).should be true
-    described_class.similar?(a, b).should be false
-  end
-
-  it 'is able to tell numbers and strings' do
-    described_class.similar?(1, 2).should be false
-    described_class.similar?('a', 'b').should be false
-    described_class.similar?('a', [1, 2, 3]).should be false
-    described_class.similar?(1, 'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5).should be false
-  end
-
-  it 'is able to tell true when similarity == 0.5' do
-    a = { 'value' => 'New1', 'onclick' => 'CreateNewDoc()' }
-    b = { 'value' => 'New', 'onclick' => 'CreateNewDoc()' }
-
-    described_class.similar?(a, b, similarity: 0.5).should be true
-  end
-
-  it 'is able to tell false when similarity == 0.5' do
-    a = { 'value' => 'New1', 'onclick' => 'open()' }
-    b = { 'value' => 'New', 'onclick' => 'CreateNewDoc()' }
-
-    described_class.similar?(a, b, similarity: 0.5).should be false
-  end
-
-  describe '.compare_values' do
-    it 'compares numeric values exactly when no tolerance' do
-      expect(described_class.compare_values(10.004, 10.003)).to be false
-    end
-
-    it 'allows tolerance with numeric values' do
-      expect(described_class.compare_values(10.004, 10.003, numeric_tolerance: 0.01)).to be true
-    end
-
-    it 'compares different objects without tolerance' do
-      expect(described_class.compare_values('hats', 'ninjas')).to be false
-    end
-
-    it 'compares other objects with tolerance' do
-      expect(described_class.compare_values('hats', 'ninjas', numeric_tolerance: 0.01)).to be false
-    end
-
-    it 'compares same objects without tolerance' do
-      expect(described_class.compare_values('horse', 'horse')).to be true
-    end
-
-    it 'compares strings for spaces exactly by default' do
-      expect(described_class.compare_values(' horse', 'horse')).to be false
-    end
-
-    it 'compares strings for capitalization exactly by default' do
-      expect(described_class.compare_values('horse', 'Horse')).to be false
-    end
-
-    it 'strips strings before comparing when requested' do
-      expect(described_class.compare_values(' horse', 'horse', strip: true)).to be true
-    end
-
-    it 'ignores string case when requested' do
-      expect(described_class.compare_values('horse', 'Horse', case_insensitive: true)).to be true
-    end
-  end
-
-  describe '.comparable?' do
-    it 'identifies hashes as comparable' do
-      expect(described_class.comparable?({}, {})).to be true
-    end
-
-    it 'identifies a subclass of Hash to be comparable with a Hash' do
-      other = Class.new(Hash)
-      expect(described_class.comparable?(other.new, {})).to be true
-    end
-
-    it 'identifies a Hash to be comparable with a subclass of Hash' do
-      other = Class.new(Hash)
-      expect(described_class.comparable?({}, other.new)).to be true
-    end
-
-    it 'does not identify a Numeric as comparable with a Hash' do
-      expect(described_class.comparable?(1, {})).to be false
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.0.1/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'rubygems'
-require 'rspec'
-require 'rspec/autorun'
-
-require 'hashdiff'
-
-RSpec.configure do |config|
-  config.mock_framework = :rspec
-
-  config.include RSpec::Matchers
-end

data/vendor/bundle/ruby/3.2.0/gems/i18n-1.14.1/lib/i18n/backend/base.rb

@@ -1,304 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'json'
-
-module I18n
-  module Backend
-    module Base
-      include I18n::Backend::Transliterator
-
-      # Accepts a list of paths to translation files. Loads translations from
-      # plain Ruby (*.rb), YAML files (*.yml), or JSON files (*.json). See #load_rb, #load_yml, and #load_json
-      # for details.
-      def load_translations(*filenames)
-        filenames = I18n.load_path if filenames.empty?
-        filenames.flatten.each do |filename|
-          loaded_translations = load_file(filename)
-          yield filename, loaded_translations if block_given?
-        end
-      end
-
-      # This method receives a locale, a data hash and options for storing translations.
-      # Should be implemented
-      def store_translations(locale, data, options = EMPTY_HASH)
-        raise NotImplementedError
-      end
-
-      def translate(locale, key, options = EMPTY_HASH)
-        raise I18n::ArgumentError if (key.is_a?(String) || key.is_a?(Symbol)) && key.empty?
-        raise InvalidLocale.new(locale) unless locale
-        return nil if key.nil? && !options.key?(:default)
-
-        entry = lookup(locale, key, options[:scope], options) unless key.nil?
-
-        if entry.nil? && options.key?(:default)
-          entry = default(locale, key, options[:default], options)
-        else
-          entry = resolve_entry(locale, key, entry, options)
-        end
-
-        count = options[:count]
-
-        if entry.nil? && (subtrees? || !count)
-          if (options.key?(:default) && !options[:default].nil?) || !options.key?(:default)
-            throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-          end
-        end
-
-        entry = entry.dup if entry.is_a?(String)
-        entry = pluralize(locale, entry, count) if count
-
-        if entry.nil? && !subtrees?
-          throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-        end
-
-        deep_interpolation = options[:deep_interpolation]
-        values = Utils.except(options, *RESERVED_KEYS) unless options.empty?
-        if values
-          entry = if deep_interpolation
-            deep_interpolate(locale, entry, values)
-          else
-            interpolate(locale, entry, values)
-          end
-        end
-        entry
-      end
-
-      def exists?(locale, key, options = EMPTY_HASH)
-        lookup(locale, key, options[:scope]) != nil
-      end
-
-      # Acts the same as +strftime+, but uses a localized version of the
-      # format string. Takes a key from the date/time formats translations as
-      # a format argument (<em>e.g.</em>, <tt>:short</tt> in <tt>:'date.formats'</tt>).
-      def localize(locale, object, format = :default, options = EMPTY_HASH)
-        if object.nil? && options.include?(:default)
-          return options[:default]
-        end
-        raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
-
-        if Symbol === format
-          key  = format
-          type = object.respond_to?(:sec) ? 'time' : 'date'
-          options = options.merge(:raise => true, :object => object, :locale => locale)
-          format  = I18n.t(:"#{type}.formats.#{key}", **options)
-        end
-
-        format = translate_localization_format(locale, object, format, options)
-        object.strftime(format)
-      end
-
-      # Returns an array of locales for which translations are available
-      # ignoring the reserved translation meta data key :i18n.
-      def available_locales
-        raise NotImplementedError
-      end
-
-      def reload!
-        eager_load! if eager_loaded?
-      end
-
-      def eager_load!
-        @eager_loaded = true
-      end
-
-      protected
-
-        def eager_loaded?
-          @eager_loaded ||= false
-        end
-
-        # The method which actually looks up for the translation in the store.
-        def lookup(locale, key, scope = [], options = EMPTY_HASH)
-          raise NotImplementedError
-        end
-
-        def subtrees?
-          true
-        end
-
-        # Evaluates defaults.
-        # If given subject is an Array, it walks the array and returns the
-        # first translation that can be resolved. Otherwise it tries to resolve
-        # the translation directly.
-        def default(locale, object, subject, options = EMPTY_HASH)
-          if options.size == 1 && options.has_key?(:default)
-            options = {}
-          else
-            options = Utils.except(options, :default)
-          end
-
-          case subject
-          when Array
-            subject.each do |item|
-              result = resolve(locale, object, item, options)
-              return result unless result.nil?
-            end and nil
-          else
-            resolve(locale, object, subject, options)
-          end
-        end
-
-        # Resolves a translation.
-        # If the given subject is a Symbol, it will be translated with the
-        # given options. If it is a Proc then it will be evaluated. All other
-        # subjects will be returned directly.
-        def resolve(locale, object, subject, options = EMPTY_HASH)
-          return subject if options[:resolve] == false
-          result = catch(:exception) do
-            case subject
-            when Symbol
-              I18n.translate(subject, **options.merge(:locale => locale, :throw => true))
-            when Proc
-              date_or_time = options.delete(:object) || object
-              resolve(locale, object, subject.call(date_or_time, **options))
-            else
-              subject
-            end
-          end
-          result unless result.is_a?(MissingTranslation)
-        end
-        alias_method :resolve_entry, :resolve
-
-        # Picks a translation from a pluralized mnemonic subkey according to English
-        # pluralization rules :
-        # - It will pick the :one subkey if count is equal to 1.
-        # - It will pick the :other subkey otherwise.
-        # - It will pick the :zero subkey in the special case where count is
-        #   equal to 0 and there is a :zero subkey present. This behaviour is
-        #   not standard with regards to the CLDR pluralization rules.
-        # Other backends can implement more flexible or complex pluralization rules.
-        def pluralize(locale, entry, count)
-          entry = entry.reject { |k, _v| k == :attributes } if entry.is_a?(Hash)
-          return entry unless entry.is_a?(Hash) && count
-
-          key = pluralization_key(entry, count)
-          raise InvalidPluralizationData.new(entry, count, key) unless entry.has_key?(key)
-          entry[key]
-        end
-
-        # Interpolates values into a given subject.
-        #
-        #   if the given subject is a string then:
-        #   method interpolates "file %{file} opened by %%{user}", :file => 'test.txt', :user => 'Mr. X'
-        #   # => "file test.txt opened by %{user}"
-        #
-        #   if the given subject is an array then:
-        #   each element of the array is recursively interpolated (until it finds a string)
-        #   method interpolates ["yes, %{user}", ["maybe no, %{user}, "no, %{user}"]], :user => "bartuz"
-        #   # => "["yes, bartuz",["maybe no, bartuz", "no, bartuz"]]"
-        def interpolate(locale, subject, values = EMPTY_HASH)
-          return subject if values.empty?
-
-          case subject
-          when ::String then I18n.interpolate(subject, values)
-          when ::Array then subject.map { |element| interpolate(locale, element, values) }
-          else
-            subject
-          end
-        end
-
-        # Deep interpolation
-        #
-        #   deep_interpolate { people: { ann: "Ann is %{ann}", john: "John is %{john}" } },
-        #                    ann: 'good', john: 'big'
-        #   #=> { people: { ann: "Ann is good", john: "John is big" } }
-        def deep_interpolate(locale, data, values = EMPTY_HASH)
-          return data if values.empty?
-
-          case data
-          when ::String
-            I18n.interpolate(data, values)
-          when ::Hash
-            data.each_with_object({}) do |(k, v), result|
-              result[k] = deep_interpolate(locale, v, values)
-            end
-          when ::Array
-            data.map do |v|
-              deep_interpolate(locale, v, values)
-            end
-          else
-            data
-          end
-        end
-
-        # Loads a single translations file by delegating to #load_rb or
-        # #load_yml depending on the file extension and directly merges the
-        # data to the existing translations. Raises I18n::UnknownFileType
-        # for all other file extensions.
-        def load_file(filename)
-          type = File.extname(filename).tr('.', '').downcase
-          raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}", true)
-          data, keys_symbolized = send(:"load_#{type}", filename)
-          unless data.is_a?(Hash)
-            raise InvalidLocaleData.new(filename, 'expects it to return a hash, but does not')
-          end
-          data.each { |locale, d| store_translations(locale, d || {}, skip_symbolize_keys: keys_symbolized) }
-
-          data
-        end
-
-        # Loads a plain Ruby translations file. eval'ing the file must yield
-        # a Hash containing translation data with locales as toplevel keys.
-        def load_rb(filename)
-          translations = eval(IO.read(filename), binding, filename)
-          [translations, false]
-        end
-
-        # Loads a YAML translations file. The data must have locales as
-        # toplevel keys.
-        def load_yml(filename)
-          begin
-            if YAML.respond_to?(:unsafe_load_file) # Psych 4.0 way
-              [YAML.unsafe_load_file(filename, symbolize_names: true, freeze: true), true]
-            else
-              [YAML.load_file(filename), false]
-            end
-          rescue TypeError, ScriptError, StandardError => e
-            raise InvalidLocaleData.new(filename, e.inspect)
-          end
-        end
-        alias_method :load_yaml, :load_yml
-
-        # Loads a JSON translations file. The data must have locales as
-        # toplevel keys.
-        def load_json(filename)
-          begin
-            # Use #load_file as a proxy for a version of JSON where symbolize_names and freeze are supported.
-            if ::JSON.respond_to?(:load_file)
-              [::JSON.load_file(filename, symbolize_names: true, freeze: true), true]
-            else
-              [::JSON.parse(File.read(filename)), false]
-            end
-          rescue TypeError, StandardError => e
-            raise InvalidLocaleData.new(filename, e.inspect)
-          end
-        end
-
-        def translate_localization_format(locale, object, format, options)
-          format.to_s.gsub(/%(|\^)[aAbBpP]/) do |match|
-            case match
-            when '%a' then I18n.t!(:"date.abbr_day_names",                  :locale => locale, :format => format)[object.wday]
-            when '%^a' then I18n.t!(:"date.abbr_day_names",                 :locale => locale, :format => format)[object.wday].upcase
-            when '%A' then I18n.t!(:"date.day_names",                       :locale => locale, :format => format)[object.wday]
-            when '%^A' then I18n.t!(:"date.day_names",                      :locale => locale, :format => format)[object.wday].upcase
-            when '%b' then I18n.t!(:"date.abbr_month_names",                :locale => locale, :format => format)[object.mon]
-            when '%^b' then I18n.t!(:"date.abbr_month_names",               :locale => locale, :format => format)[object.mon].upcase
-            when '%B' then I18n.t!(:"date.month_names",                     :locale => locale, :format => format)[object.mon]
-            when '%^B' then I18n.t!(:"date.month_names",                    :locale => locale, :format => format)[object.mon].upcase
-            when '%p' then I18n.t!(:"time.#{(object.respond_to?(:hour) ? object.hour : 0) < 12 ? :am : :pm}", :locale => locale, :format => format).upcase
-            when '%P' then I18n.t!(:"time.#{(object.respond_to?(:hour) ? object.hour : 0) < 12 ? :am : :pm}", :locale => locale, :format => format).downcase
-            end
-          end
-        rescue MissingTranslationData => e
-          e.message
-        end
-
-        def pluralization_key(entry, count)
-          key = :zero if count == 0 && entry.has_key?(:zero)
-          key ||= count == 1 ? :one : :other
-        end
-    end
-  end
-end