logstash-filter-zabbix 0.1.1

data/vendor/bundle/jruby/1.9/gems/gems-0.8.3/spec/gems_spec.rb

@@ -0,0 +1,73 @@
+require 'helper'
+
+describe Gems do
+  after do
+    Gems.reset
+  end
+
+  context "when delegating to a client" do
+    before do
+      stub_get("/api/v1/gems/rails.yaml").
+        to_return(:body => fixture("rails.yaml"))
+    end
+
+    it "gets the correct resource" do
+      Gems.info('rails')
+      expect(a_get("/api/v1/gems/rails.yaml")).to have_been_made
+    end
+
+    it "returns the same results as a client" do
+      expect(Gems.info('rails')).to eq Gems::Client.new.info('rails')
+    end
+  end
+
+  describe '.respond_to?' do
+    it "takes an optional argument" do
+      expect(Gems.respond_to?(:new, true)).to be_true
+    end
+  end
+
+  describe ".new" do
+    it "returns a Gems::Client" do
+      expect(Gems.new).to be_a Gems::Client
+    end
+  end
+
+  describe ".host" do
+    it "returns the default host" do
+      expect(Gems.host).to eq Gems::Configuration::DEFAULT_HOST
+    end
+  end
+
+  describe ".host=" do
+    it "sets the host" do
+      Gems.host = 'http://localhost:3000'
+      expect(Gems.host).to eq 'http://localhost:3000'
+    end
+  end
+
+  describe ".user_agent" do
+    it "returns the default user agent" do
+      expect(Gems.user_agent).to eq Gems::Configuration::DEFAULT_USER_AGENT
+    end
+  end
+
+  describe ".user_agent=" do
+    it "sets the user agent" do
+      Gems.user_agent = 'Custom User Agent'
+      expect(Gems.user_agent).to eq 'Custom User Agent'
+    end
+  end
+
+  describe ".configure" do
+    Gems::Configuration::VALID_OPTIONS_KEYS.each do |key|
+      it "sets the #{key}" do
+        Gems.configure do |config|
+          config.send("#{key}=", key)
+          expect(Gems.send(key)).to eq key
+        end
+      end
+    end
+  end
+
+end

data/vendor/bundle/jruby/1.9/gems/gems-0.8.3/spec/helper.rb

@@ -0,0 +1,64 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require 'gems'
+require 'rspec'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!(:allow => 'coveralls.io')
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+def rubygems_url(url)
+  url =~ /^http/ ? url : 'https://rubygems.org' + url
+end
+
+def a_delete(url)
+  a_request(:delete, rubygems_url(url))
+end
+
+def a_get(url)
+  a_request(:get, rubygems_url(url))
+end
+
+def a_post(url)
+  a_request(:post, rubygems_url(url))
+end
+
+def a_put(url)
+  a_request(:put, rubygems_url(url))
+end
+
+def stub_delete(url)
+  stub_request(:delete, rubygems_url(url))
+end
+
+def stub_get(url)
+  stub_request(:get, rubygems_url(url))
+end
+
+def stub_post(url)
+  stub_request(:post, rubygems_url(url))
+end
+
+def stub_put(url)
+  stub_request(:put, rubygems_url(url))
+end
+
+def fixture_path
+  File.expand_path('../fixtures', __FILE__)
+end
+
+def fixture(file)
+  File.new(fixture_path + '/' + file)
+end

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 The Ruby I18n team
+
+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/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/README.textile

@@ -0,0 +1,105 @@
+h1. Ruby I18n
+
+!https://secure.travis-ci.org/svenfuchs/i18n.png?branch=master(Build Status)!:http://travis-ci.org/svenfuchs/i18n
+
+Ruby Internationalization and localization solution.
+
+Features:
+
+* translation and localization
+* interpolation of values to translations (Ruby 1.9 compatible syntax)
+* pluralization (CLDR compatible)
+* customizable transliteration to ASCII
+* flexible defaults
+* bulk lookup
+* lambdas as translation data
+* custom key/scope separator
+* custom exception handlers
+* extensible architecture with a swappable backend
+
+Pluggable features:
+
+* Cache
+* Pluralization: lambda pluralizers stored as translation data
+* Locale fallbacks, RFC4647 compliant (optionally: RFC4646 locale validation)
+* Gettext support
+* Translation metadata
+
+Alternative backends:
+
+* Chain
+* ActiveRecord (optionally: ActiveRecord::Missing and ActiveRecord::StoreProcs)
+* KeyValue (uses active_support/json and cannot store procs)
+
+For more information and lots of resources see: "http://ruby-i18n.org/wiki":http://ruby-i18n.org/wiki
+
+h2. Installation
+
+gem install i18n
+
+h4. Rails version warning
+
+On Rails < 2.3.6 the method I18n.localize will fail with MissingInterpolationArgument (issue "20":http://github.com/svenfuchs/i18n/issues/issue/20). Upgrade to Rails 2.3.6 or higher (2.3.8 preferably) is recommended.
+
+h3. Installation on Rails < 2.3.5 (deprecated)
+
+Up to version 2.3.4 Rails will not accept i18n gems > 0.1.3. There is an unpacked
+gem inside of active_support/lib/vendor which gets loaded unless gem 'i18n', '~> 0.1.3'.
+This requirement is relaxed in "6da03653":http://github.com/rails/rails/commit/6da03653
+
+The new i18n gem can be loaded from vendor/plugins like this:
+
+<pre>
+  def reload_i18n!
+    raise "Move to i18n version 0.2.0 or greater" if Rails.version > "2.3.4"
+
+    $:.grep(/i18n/).each { |path| $:.delete(path) }
+    I18n::Backend.send :remove_const, "Simple"
+    $: << Rails.root.join('vendor', 'plugins', 'i18n', 'lib').to_s
+  end
+</pre>
+
+Then you can `reload_i18n!` inside an i18n initializer.
+
+h2. Tests
+
+You can run tests both with
+
+* `rake test` or just `rake`
+* run any test file directly, e.g. `ruby -Ilib -Itest test/api/simple_test.rb`
+* run all tests with `ruby -Ilib -Itest test/all.rb`
+
+You can run all tests against all Gemfiles with
+
+* `ruby test/run_all.rb`
+
+The structure of the test suite is a bit unusual as it uses modules to reuse
+particular tests in different test cases.
+
+The reason for this is that we need to enforce the I18n API across various
+combinations of extensions. E.g. the Simple backend alone needs to support
+the same API as any combination of feature and/or optimization modules included
+to the Simple backend. We test this by reusing the same API defition (implemented
+as test methods) in test cases with different setups.
+
+You can find the test cases that enforce the API in test/api. And you can find
+the API definition test methods in test/api/tests.
+
+All other test cases (e.g. as defined in test/backend, test/core\_ext) etc.
+follow the usual test setup and should be easy to grok.
+
+h2. Authors
+
+* "Sven Fuchs":http://www.artweb-design.de
+* "Joshua Harvey":http://www.workingwithrails.com/person/759-joshua-harvey
+* "Stephan Soller":http://www.arkanis-development.de
+* "Saimon Moore":http://saimonmoore.net
+* "Matt Aimonetti":http://railsontherun.com
+
+h2. Contributors
+
+http://github.com/svenfuchs/i18n/contributors
+
+h2. License
+
+MIT License. See the included MIT-LICENSE file.

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/ci/Gemfile.no-rails

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'mocha'
+gem 'test_declarative'
+

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/ci/Gemfile.no-rails.lock

@@ -0,0 +1,14 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    mocha (0.9.9)
+      rake
+    rake (0.8.7)
+    test_declarative (0.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  test_declarative

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/ci/Gemfile.rails-2.3.x

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'activesupport', '~> 2.3'
+gem 'sqlite3-ruby'
+gem 'mocha'
+gem 'test_declarative'
+gem 'rufus-tokyo'
+gem 'ffi'
+

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/ci/Gemfile.rails-2.3.x.lock

@@ -0,0 +1,23 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (2.3.10)
+    ffi (0.6.3)
+      rake (>= 0.8.7)
+    mocha (0.9.9)
+      rake
+    rake (0.8.7)
+    rufus-tokyo (1.0.7)
+    sqlite3-ruby (1.3.2)
+    test_declarative (0.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 2.3)
+  ffi
+  mocha
+  rufus-tokyo
+  sqlite3-ruby
+  test_declarative

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/ci/Gemfile.rails-3.x

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'activesupport', '~> 3.0.0'
+gem 'sqlite3-ruby'
+gem 'mocha'
+gem 'test_declarative'
+gem 'rufus-tokyo'
+gem 'ffi'
+

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/ci/Gemfile.rails-3.x.lock

@@ -0,0 +1,23 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.3)
+    ffi (0.6.3)
+      rake (>= 0.8.7)
+    mocha (0.9.9)
+      rake
+    rake (0.8.7)
+    rufus-tokyo (1.0.7)
+    sqlite3-ruby (1.3.2)
+    test_declarative (0.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 3.0.0)
+  ffi
+  mocha
+  rufus-tokyo
+  sqlite3-ruby
+  test_declarative

data/vendor/bundle/jruby/1.9/gems/i18n-0.6.9/lib/i18n.rb

@@ -0,0 +1,367 @@
+require 'i18n/version'
+require 'i18n/exceptions'
+require 'i18n/interpolate/ruby'
+
+module I18n
+  autoload :Backend, 'i18n/backend'
+  autoload :Config,  'i18n/config'
+  autoload :Gettext, 'i18n/gettext'
+  autoload :Locale,  'i18n/locale'
+  autoload :Tests,   'i18n/tests'
+
+  RESERVED_KEYS = [:scope, :default, :separator, :resolve, :object, :fallback, :format, :cascade, :throw, :raise, :rescue_format]
+  RESERVED_KEYS_PATTERN = /%\{(#{RESERVED_KEYS.join("|")})\}/
+
+  extend(Module.new {
+    # Gets I18n configuration object.
+    def config
+      Thread.current[:i18n_config] ||= I18n::Config.new
+    end
+
+    # Sets I18n configuration object.
+    def config=(value)
+      Thread.current[:i18n_config] = value
+    end
+
+    # Write methods which delegates to the configuration object
+    %w(locale backend default_locale available_locales default_separator
+      exception_handler load_path enforce_available_locales).each do |method|
+      module_eval <<-DELEGATORS, __FILE__, __LINE__ + 1
+        def #{method}
+          config.#{method}
+        end
+
+        def #{method}=(value)
+          config.#{method} = (value)
+        end
+      DELEGATORS
+    end
+
+    # Tells the backend to reload translations. Used in situations like the
+    # Rails development environment. Backends can implement whatever strategy
+    # is useful.
+    def reload!
+      config.backend.reload!
+    end
+
+    # Translates, pluralizes and interpolates a given key using a given locale,
+    # scope, and default, as well as interpolation values.
+    #
+    # *LOOKUP*
+    #
+    # Translation data is organized as a nested hash using the upper-level keys
+    # as namespaces. <em>E.g.</em>, ActionView ships with the translation:
+    # <tt>:date => {:formats => {:short => "%b %d"}}</tt>.
+    #
+    # Translations can be looked up at any level of this hash using the key argument
+    # and the scope option. <em>E.g.</em>, in this example <tt>I18n.t :date</tt>
+    # returns the whole translations hash <tt>{:formats => {:short => "%b %d"}}</tt>.
+    #
+    # Key can be either a single key or a dot-separated key (both Strings and Symbols
+    # work). <em>E.g.</em>, the short format can be looked up using both:
+    #   I18n.t 'date.formats.short'
+    #   I18n.t :'date.formats.short'
+    #
+    # Scope can be either a single key, a dot-separated key or an array of keys
+    # or dot-separated keys. Keys and scopes can be combined freely. So these
+    # examples will all look up the same short date format:
+    #   I18n.t 'date.formats.short'
+    #   I18n.t 'formats.short', :scope => 'date'
+    #   I18n.t 'short', :scope => 'date.formats'
+    #   I18n.t 'short', :scope => %w(date formats)
+    #
+    # *INTERPOLATION*
+    #
+    # Translations can contain interpolation variables which will be replaced by
+    # values passed to #translate as part of the options hash, with the keys matching
+    # the interpolation variable names.
+    #
+    # <em>E.g.</em>, with a translation <tt>:foo => "foo %{bar}"</tt> the option
+    # value for the key +bar+ will be interpolated into the translation:
+    #   I18n.t :foo, :bar => 'baz' # => 'foo baz'
+    #
+    # *PLURALIZATION*
+    #
+    # Translation data can contain pluralized translations. Pluralized translations
+    # are arrays of singluar/plural versions of translations like <tt>['Foo', 'Foos']</tt>.
+    #
+    # Note that <tt>I18n::Backend::Simple</tt> only supports an algorithm for English
+    # pluralization rules. Other algorithms can be supported by custom backends.
+    #
+    # This returns the singular version of a pluralized translation:
+    #   I18n.t :foo, :count => 1 # => 'Foo'
+    #
+    # These both return the plural version of a pluralized translation:
+    #   I18n.t :foo, :count => 0 # => 'Foos'
+    #   I18n.t :foo, :count => 2 # => 'Foos'
+    #
+    # The <tt>:count</tt> option can be used both for pluralization and interpolation.
+    # <em>E.g.</em>, with the translation
+    # <tt>:foo => ['%{count} foo', '%{count} foos']</tt>, count will
+    # be interpolated to the pluralized translation:
+    #   I18n.t :foo, :count => 1 # => '1 foo'
+    #
+    # *DEFAULTS*
+    #
+    # This returns the translation for <tt>:foo</tt> or <tt>default</tt> if no translation was found:
+    #   I18n.t :foo, :default => 'default'
+    #
+    # This returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt> if no
+    # translation for <tt>:foo</tt> was found:
+    #   I18n.t :foo, :default => :bar
+    #
+    # Returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt>
+    # or <tt>default</tt> if no translations for <tt>:foo</tt> and <tt>:bar</tt> were found.
+    #   I18n.t :foo, :default => [:bar, 'default']
+    #
+    # *BULK LOOKUP*
+    #
+    # This returns an array with the translations for <tt>:foo</tt> and <tt>:bar</tt>.
+    #   I18n.t [:foo, :bar]
+    #
+    # Can be used with dot-separated nested keys:
+    #   I18n.t [:'baz.foo', :'baz.bar']
+    #
+    # Which is the same as using a scope option:
+    #   I18n.t [:foo, :bar], :scope => :baz
+    #
+    # *LAMBDAS*
+    #
+    # Both translations and defaults can be given as Ruby lambdas. Lambdas will be
+    # called and passed the key and options.
+    #
+    # E.g. assuming the key <tt>:salutation</tt> resolves to:
+    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. %{options[:name]}" : "Mrs. %{options[:name]}" }
+    #
+    # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith') will result in "Mrs. Smith".
+    #
+    # It is recommended to use/implement lambdas in an "idempotent" way. E.g. when
+    # a cache layer is put in front of I18n.translate it will generate a cache key
+    # from the argument values passed to #translate. Therefor your lambdas should
+    # always return the same translations/values per unique combination of argument
+    # values.
+    def translate(*args)
+      options  = args.last.is_a?(Hash) ? args.pop.dup : {}
+      key      = args.shift
+      backend  = config.backend
+      locale   = options.delete(:locale) || config.locale
+      handling = options.delete(:throw) && :throw || options.delete(:raise) && :raise # TODO deprecate :raise
+
+      enforce_available_locales!(locale)
+      raise I18n::ArgumentError if key.is_a?(String) && key.empty?
+
+      result = catch(:exception) do
+        if key.is_a?(Array)
+          key.map { |k| backend.translate(locale, k, options) }
+        else
+          backend.translate(locale, key, options)
+        end
+      end
+      result.is_a?(MissingTranslation) ? handle_exception(handling, result, locale, key, options) : result
+    end
+    alias :t :translate
+
+    # Wrapper for <tt>translate</tt> that adds <tt>:raise => true</tt>. With
+    # this option, if no translation is found, it will raise <tt>I18n::MissingTranslationData</tt>
+    def translate!(key, options={})
+      translate(key, options.merge(:raise => true))
+    end
+    alias :t! :translate!
+
+    # Returns true if a translation exists for a given key, otherwise returns false.
+    def exists?(key, locale = config.locale)
+      raise I18n::ArgumentError if key.is_a?(String) && key.empty?
+      config.backend.exists?(locale, key)
+    end
+
+    # Transliterates UTF-8 characters to ASCII. By default this method will
+    # transliterate only Latin strings to an ASCII approximation:
+    #
+    #    I18n.transliterate("Ærøskøbing")
+    #    # => "AEroskobing"
+    #
+    #    I18n.transliterate("日本語")
+    #    # => "???"
+    #
+    # It's also possible to add support for per-locale transliterations. I18n
+    # expects transliteration rules to be stored at
+    # <tt>i18n.transliterate.rule</tt>.
+    #
+    # Transliteration rules can either be a Hash or a Proc. Procs must accept a
+    # single string argument. Hash rules inherit the default transliteration
+    # rules, while Procs do not.
+    #
+    # *Examples*
+    #
+    # Setting a Hash in <locale>.yml:
+    #
+    #    i18n:
+    #      transliterate:
+    #        rule:
+    #          ü: "ue"
+    #          ö: "oe"
+    #
+    # Setting a Hash using Ruby:
+    #
+    #     store_translations(:de, :i18n => {
+    #       :transliterate => {
+    #         :rule => {
+    #           "ü" => "ue",
+    #           "ö" => "oe"
+    #         }
+    #       }
+    #     )
+    #
+    # Setting a Proc:
+    #
+    #     translit = lambda {|string| MyTransliterator.transliterate(string) }
+    #     store_translations(:xx, :i18n => {:transliterate => {:rule => translit})
+    #
+    # Transliterating strings:
+    #
+    #     I18n.locale = :en
+    #     I18n.transliterate("Jürgen") # => "Jurgen"
+    #     I18n.locale = :de
+    #     I18n.transliterate("Jürgen") # => "Juergen"
+    #     I18n.transliterate("Jürgen", :locale => :en) # => "Jurgen"
+    #     I18n.transliterate("Jürgen", :locale => :de) # => "Juergen"
+    def transliterate(*args)
+      options      = args.pop.dup if args.last.is_a?(Hash)
+      key          = args.shift
+      locale       = options && options.delete(:locale) || config.locale
+      handling     = options && (options.delete(:throw) && :throw || options.delete(:raise) && :raise)
+      replacement  = options && options.delete(:replacement)
+      enforce_available_locales!(locale)
+      config.backend.transliterate(locale, key, replacement)
+    rescue I18n::ArgumentError => exception
+      handle_exception(handling, exception, locale, key, options || {})
+    end
+
+    # Localizes certain objects, such as dates and numbers to local formatting.
+    def localize(object, options = nil)
+      options = options ? options.dup : {}
+      locale = options.delete(:locale) || config.locale
+      format = options.delete(:format) || :default
+      enforce_available_locales!(locale)
+      config.backend.localize(locale, object, format, options)
+    end
+    alias :l :localize
+
+    # Executes block with given I18n.locale set.
+    def with_locale(tmp_locale = nil)
+      if tmp_locale
+        current_locale = self.locale
+        self.locale    = tmp_locale
+      end
+      yield
+    ensure
+      self.locale = current_locale if tmp_locale
+    end
+
+    # Merges the given locale, key and scope into a single array of keys.
+    # Splits keys that contain dots into multiple keys. Makes sure all
+    # keys are Symbols.
+    def normalize_keys(locale, key, scope, separator = nil)
+      separator ||= I18n.default_separator
+
+      keys = []
+      keys.concat normalize_key(locale, separator)
+      keys.concat normalize_key(scope, separator)
+      keys.concat normalize_key(key, separator)
+      keys
+    end
+
+    # Returns true when the passed locale is in I18.available_locales.
+    # Returns false otherwise.
+    # Compare with Strings as `locale` may be coming from user input
+    def locale_available?(locale)
+      I18n.available_locales.map(&:to_s).include?(locale.to_s)
+    end
+
+    # Raises an InvalidLocale exception when the passed locale is not
+    # included in I18n.available_locales.
+    # Returns false otherwise
+    def enforce_available_locales!(locale)
+      handle_enforce_available_locales_deprecation
+
+      if config.enforce_available_locales
+        raise I18n::InvalidLocale.new(locale) if !locale_available?(locale)
+      end
+    end
+
+  # making these private until Ruby 1.9.2 can send to protected methods again
+  # see http://redmine.ruby-lang.org/repositories/revision/ruby-19?rev=24280
+  private
+
+    # Any exceptions thrown in translate will be sent to the @@exception_handler
+    # which can be a Symbol, a Proc or any other Object unless they're forced to
+    # be raised or thrown (MissingTranslation).
+    #
+    # If exception_handler is a Symbol then it will simply be sent to I18n as
+    # a method call. A Proc will simply be called. In any other case the
+    # method #call will be called on the exception_handler object.
+    #
+    # Examples:
+    #
+    #   I18n.exception_handler = :default_exception_handler             # this is the default
+    #   I18n.default_exception_handler(exception, locale, key, options) # will be called like this
+    #
+    #   I18n.exception_handler = lambda { |*args| ... }                 # a lambda
+    #   I18n.exception_handler.call(exception, locale, key, options)    # will be called like this
+    #
+    #  I18n.exception_handler = I18nExceptionHandler.new                # an object
+    #  I18n.exception_handler.call(exception, locale, key, options)     # will be called like this
+    def handle_exception(handling, exception, locale, key, options)
+      case handling
+      when :raise
+        raise(exception.respond_to?(:to_exception) ? exception.to_exception : exception)
+      when :throw
+        throw :exception, exception
+      else
+        case handler = options[:exception_handler] || config.exception_handler
+        when Symbol
+          send(handler, exception, locale, key, options)
+        else
+          handler.call(exception, locale, key, options)
+        end
+      end
+    end
+
+    def normalize_key(key, separator)
+      normalized_key_cache[separator][key] ||=
+        case key
+        when Array
+          key.map { |k| normalize_key(k, separator) }.flatten
+        else
+          keys = key.to_s.split(separator)
+          keys.delete('')
+          keys.map! { |k| k.to_sym }
+          keys
+        end
+    end
+
+    def normalized_key_cache
+      @normalized_key_cache ||= Hash.new { |h,k| h[k] = {} }
+    end
+
+    # DEPRECATED. Use I18n.normalize_keys instead.
+    def normalize_translation_keys(locale, key, scope, separator = nil)
+      puts "I18n.normalize_translation_keys is deprecated. Please use the class I18n.normalize_keys instead."
+      normalize_keys(locale, key, scope, separator)
+    end
+
+    # DEPRECATED. Please use the I18n::ExceptionHandler class instead.
+    def default_exception_handler(exception, locale, key, options)
+      puts "I18n.default_exception_handler is deprecated. Please use the class I18n::ExceptionHandler instead " +
+           "(an instance of which is set to I18n.exception_handler by default)."
+      exception.is_a?(MissingTranslation) ? exception.message : raise(exception)
+    end
+
+    def handle_enforce_available_locales_deprecation
+      if config.enforce_available_locales.nil? && !@unenforced_available_locales_deprecation
+        $stderr.puts "[deprecated] I18n.enforce_available_locales will default to true in the future. If you really want to skip validation of your locale you can set I18n.enforce_available_locales = false to avoid this message." 
+        @unenforced_available_locales_deprecation = true
+      end
+    end
+  })
+end