sidekiq-statsd 0.1.1 → 0.1.2

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/locale/fallbacks.rb

@@ -1,96 +0,0 @@
-# Locale Fallbacks
-#
-# Extends the I18n module to hold a fallbacks instance which is set to an
-# instance of I18n::Locale::Fallbacks by default but can be swapped with a
-# different implementation.
-#
-# Locale fallbacks will compute a number of fallback locales for a given locale.
-# For example:
-#
-# <pre><code>
-# I18n.fallbacks[:"es-MX"] # => [:"es-MX", :es, :en] </code></pre>
-#
-# Locale fallbacks always fall back to
-#
-#   * all parent locales of a given locale (e.g. :es for :"es-MX") first,
-#   * the current default locales and all of their parents second
-#
-# The default locales are set to [I18n.default_locale] by default but can be
-# set to something else.
-#
-# One can additionally add any number of additional fallback locales manually.
-# These will be added before the default locales to the fallback chain. For
-# example:
-#
-#   # using the default locale as default fallback locale
-#
-#   I18n.default_locale = :"en-US"
-#   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"de-AT" => :"de-DE")
-#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :"de-DE", :de, :"en-US", :en]
-#
-#   # using a custom locale as default fallback locale
-#
-#   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
-#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :de, :"en-GB", :en]
-#   I18n.fallbacks[:"de-CH"] # => [:"de-CH", :de, :"en-GB", :en]
-#
-#   # mapping fallbacks to an existing instance
-#
-#   # people speaking Catalan also speak Spanish as spoken in Spain
-#   fallbacks = I18n.fallbacks
-#   fallbacks.map(:ca => :"es-ES")
-#   fallbacks[:ca] # => [:ca, :"es-ES", :es, :"en-US", :en]
-#
-#   # people speaking Arabian as spoken in Palestine also speak Hebrew as spoken in Israel
-#   fallbacks.map(:"ar-PS" => :"he-IL")
-#   fallbacks[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
-#   fallbacks[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
-#
-#   # people speaking Sami as spoken in Finnland also speak Swedish and Finnish as spoken in Finnland
-#   fallbacks.map(:sms => [:"se-FI", :"fi-FI"])
-#   fallbacks[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
-
-module I18n
-  module Locale
-    class Fallbacks < Hash
-      def initialize(*mappings)
-        @map = {}
-        map(mappings.pop) if mappings.last.is_a?(Hash)
-        self.defaults = mappings.empty? ? [I18n.default_locale.to_sym] : mappings
-      end
-
-      def defaults=(defaults)
-        @defaults = defaults.map { |default| compute(default, false) }.flatten
-      end
-      attr_reader :defaults
-
-      def [](locale)
-        raise InvalidLocale.new(locale) if locale.nil?
-        locale = locale.to_sym
-        super || store(locale, compute(locale))
-      end
-
-      def map(mappings)
-        mappings.each do |from, to|
-          from, to = from.to_sym, Array(to)
-          to.each do |_to|
-            @map[from] ||= []
-            @map[from] << _to.to_sym
-          end
-        end
-      end
-
-      protected
-
-      def compute(tags, include_defaults = true, exclude = [])
-        result = Array(tags).collect do |tag|
-          tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym } - exclude
-          tags.each { |_tag| tags += compute(@map[_tag], false, exclude + tags) if @map[_tag] }
-          tags
-        end.flatten
-        result.push(*defaults) if include_defaults
-        result.uniq.compact
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/locale/tag/parents.rb

@@ -1,22 +0,0 @@
-module I18n
-  module Locale
-    module Tag
-      module Parents
-        def parent
-          @parent ||= begin
-            segs = to_a.compact
-            segs.length > 1 ? self.class.tag(*segs[0..(segs.length-2)].join('-')) : nil
-          end
-        end
-
-        def self_and_parents
-          @self_and_parents ||= [self] + parents
-        end
-
-        def parents
-          @parents ||= ([parent] + (parent ? parent.parents : [])).compact
-        end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/locale/tag/rfc4646.rb

@@ -1,74 +0,0 @@
-# RFC 4646/47 compliant Locale tag implementation that parses locale tags to
-# subtags such as language, script, region, variant etc.
-#
-# For more information see by http://en.wikipedia.org/wiki/IETF_language_tag
-#
-# Rfc4646::Parser does not implement grandfathered tags.
-
-module I18n
-  module Locale
-    module Tag
-      RFC4646_SUBTAGS = [ :language, :script, :region, :variant, :extension, :privateuse, :grandfathered ]
-      RFC4646_FORMATS = { :language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase }
-
-      class Rfc4646 < Struct.new(*RFC4646_SUBTAGS)
-        class << self
-          # Parses the given tag and returns a Tag instance if it is valid.
-          # Returns false if the given tag is not valid according to RFC 4646.
-          def tag(tag)
-            matches = parser.match(tag)
-            new(*matches) if matches
-          end
-
-          def parser
-            @@parser ||= Rfc4646::Parser
-          end
-
-          def parser=(parser)
-            @@parser = parser
-          end
-        end
-
-        include Parents
-
-        RFC4646_FORMATS.each do |name, format|
-          define_method(name) { self[name].send(format) unless self[name].nil? }
-        end
-
-        def to_sym
-          to_s.to_sym
-        end
-
-        def to_s
-          @tag ||= to_a.compact.join("-")
-        end
-
-        def to_a
-          members.collect { |attr| self.send(attr) }
-        end
-
-        module Parser
-          PATTERN = %r{\A(?:
-            ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
-            (?:-([a-z]{4}))?                                        # script
-            (?:-([a-z]{2}|\d{3}))?                                  # region
-            (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
-            (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
-            (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
-            (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
-            /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
-            )\z}xi
-
-          class << self
-            def match(tag)
-              c = PATTERN.match(tag.to_s).captures
-              c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
-            rescue
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/locale/tag/simple.rb

@@ -1,39 +0,0 @@
-# Simple Locale tag implementation that computes subtags by simply splitting
-# the locale tag at '-' occurences.
-module I18n
-  module Locale
-    module Tag
-      class Simple
-        class << self
-          def tag(tag)
-            new(tag)
-          end
-        end
-
-        include Parents
-
-        attr_reader :tag
-
-        def initialize(*tag)
-          @tag = tag.join('-').to_sym
-        end
-
-        def subtags
-          @subtags = tag.to_s.split('-').map { |subtag| subtag.to_s }
-        end
-
-        def to_sym
-          tag
-        end
-
-        def to_s
-          tag.to_s
-        end
-
-        def to_a
-          subtags
-        end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/locale/tag.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Locale
-    module Tag
-      autoload :Parents, 'i18n/locale/tag/parents'
-      autoload :Rfc4646, 'i18n/locale/tag/rfc4646'
-      autoload :Simple,  'i18n/locale/tag/simple'
-
-      class << self
-        # Returns the current locale tag implementation. Defaults to +I18n::Locale::Tag::Simple+.
-        def implementation
-          @@implementation ||= Simple
-        end
-
-        # Sets the current locale tag implementation. Use this to set a different locale tag implementation.
-        def implementation=(implementation)
-          @@implementation = implementation
-        end
-
-        # Factory method for locale tags. Delegates to the current locale tag implementation.
-        def tag(tag)
-          implementation.tag(tag)
-        end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/locale.rb

@@ -1,6 +0,0 @@
-module I18n
-  module Locale
-  autoload :Fallbacks, 'i18n/locale/fallbacks'
-  autoload :Tag,       'i18n/locale/tag'
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/tests/basics.rb

@@ -1,54 +0,0 @@
-module I18n
-  module Tests
-    module Basics
-      def teardown
-        I18n.available_locales = nil
-      end
-
-      test "available_locales returns the locales stored to the backend by default" do
-        I18n.backend.store_translations('de', :foo => 'bar')
-        I18n.backend.store_translations('en', :foo => 'foo')
-
-        assert I18n.available_locales.include?(:de)
-        assert I18n.available_locales.include?(:en)
-      end
-
-      test "available_locales can be set to something else independently from the actual locale data" do
-        I18n.backend.store_translations('de', :foo => 'bar')
-        I18n.backend.store_translations('en', :foo => 'foo')
-
-        I18n.available_locales = :foo
-        assert_equal [:foo], I18n.available_locales
-
-        I18n.available_locales = [:foo, 'bar']
-        assert_equal [:foo, :bar], I18n.available_locales
-
-        I18n.available_locales = nil
-        assert I18n.available_locales.include?(:de)
-        assert I18n.available_locales.include?(:en)
-      end
-
-      test "available_locales memoizes when set explicitely" do
-        I18n.backend.expects(:available_locales).never
-        I18n.available_locales = [:foo]
-        I18n.backend.store_translations('de', :bar => 'baz')
-        I18n.reload!
-        assert_equal [:foo], I18n.available_locales
-      end
-
-      test "available_locales delegates to the backend when not set explicitely" do
-        I18n.backend.expects(:available_locales).twice
-        assert_equal I18n.available_locales, I18n.available_locales
-      end
-
-      test "storing a nil value as a translation removes it from the available locale data" do
-        I18n.backend.store_translations(:en, :to_be_deleted => 'bar')
-        assert_equal 'bar', I18n.t(:to_be_deleted, :default => 'baz')
-
-        I18n.cache_store.clear if I18n.respond_to?(:cache_store) && I18n.cache_store
-        I18n.backend.store_translations(:en, :to_be_deleted => nil)
-        assert_equal 'baz', I18n.t(:to_be_deleted, :default => 'baz')
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/tests/defaults.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Tests
-    module Defaults
-      def setup
-        super
-        I18n.backend.store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
-      end
-
-      test "defaults: given nil as a key it returns the given default" do
-        assert_equal 'default', I18n.t(nil, :default => 'default')
-      end
-
-      test "defaults: given a symbol as a default it translates the symbol" do
-        assert_equal 'bar', I18n.t(nil, :default => :'foo.bar')
-      end
-
-      test "defaults: given a symbol as a default and a scope it stays inside the scope when looking up the symbol" do
-        assert_equal 'bar', I18n.t(:missing, :default => :bar, :scope => :foo)
-      end
-
-      test "defaults: given an array as a default it returns the first match" do
-        assert_equal 'bar', I18n.t(:does_not_exist, :default => [:does_not_exist_2, :'foo.bar'])
-      end
-
-      test "defaults: given an array of missing keys it raises a MissingTranslationData exception" do
-        assert_raise I18n::MissingTranslationData do
-          I18n.t(:does_not_exist, :default => [:does_not_exist_2, :does_not_exist_3], :raise => true)
-        end
-      end
-
-      test "defaults: using a custom scope separator" do
-        # data must have been stored using the custom separator when using the ActiveRecord backend
-        I18n.backend.store_translations(:en, { :foo => { :bar => 'bar' } }, { :separator => '|' })
-        assert_equal 'bar', I18n.t(nil, :default => :'foo|bar', :separator => '|')
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/tests/interpolation.rb

@@ -1,133 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Tests
-    module Interpolation
-      # If no interpolation parameter is not given, I18n should not alter the string.
-      # This behavior is due to three reasons:
-      #
-      #   * Checking interpolation keys in all strings hits performance, badly;
-      #
-      #   * This allows us to retrieve untouched values through I18n. For example
-      #     I could have a middleware that returns I18n lookup results in JSON
-      #     to be processed through Javascript. Leaving the keys untouched allows
-      #     the interpolation to happen at the javascript level;
-      #
-      #   * Security concerns: if I allow users to translate a web site, they can
-      #     insert %{} in messages causing the I18n lookup to fail in every request.
-      #
-      test "interpolation: given no values it does not alter the string" do
-        assert_equal 'Hi %{name}!', interpolate(:default => 'Hi %{name}!')
-      end
-
-      test "interpolation: given values it interpolates them into the string" do
-        assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => 'David')
-      end
-
-      test "interpolation: given a nil value it still interpolates it into the string" do
-        assert_equal 'Hi !', interpolate(:default => 'Hi %{name}!', :name => nil)
-      end
-
-      test "interpolation: given a lambda as a value it calls it if the string contains the key" do
-        assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => lambda { |*args| 'David' })
-      end
-
-      test "interpolation: given a lambda as a value it does not call it if the string does not contain the key" do
-        assert_nothing_raised { interpolate(:default => 'Hi!', :name => lambda { |*args| raise 'fail' }) }
-      end
-
-      test "interpolation: given values but missing a key it raises I18n::MissingInterpolationArgument" do
-        assert_raise(I18n::MissingInterpolationArgument) do
-          interpolate(:default => '%{foo}', :bar => 'bar')
-        end
-      end
-
-      test "interpolation: it does not raise I18n::MissingInterpolationArgument for escaped variables" do
-        assert_nothing_raised(I18n::MissingInterpolationArgument) do
-          assert_equal 'Barr %{foo}', interpolate(:default => '%{bar} %%{foo}', :bar => 'Barr')
-        end
-      end
-
-      test "interpolation: it does not change the original, stored translation string" do
-        I18n.backend.store_translations(:en, :interpolate => 'Hi %{name}!')
-        assert_equal 'Hi David!', interpolate(:interpolate, :name => 'David')
-        assert_equal 'Hi Yehuda!', interpolate(:interpolate, :name => 'Yehuda')
-      end
-
-      test "interpolation: given the translation is in utf-8 it still works" do
-        assert_equal 'Häi David!', interpolate(:default => 'Häi %{name}!', :name => 'David')
-      end
-
-      test "interpolation: given the value is in utf-8 it still works" do
-        assert_equal 'Hi ゆきひろ!', interpolate(:default => 'Hi %{name}!', :name => 'ゆきひろ')
-      end
-
-      test "interpolation: given the translation and the value are in utf-8 it still works" do
-        assert_equal 'こんにちは、ゆきひろさん!', interpolate(:default => 'こんにちは、%{name}さん!', :name => 'ゆきひろ')
-      end
-
-      if Kernel.const_defined?(:Encoding)
-        test "interpolation: given a euc-jp translation and a utf-8 value it raises Encoding::CompatibilityError" do
-          assert_raise(Encoding::CompatibilityError) do
-            interpolate(:default => euc_jp('こんにちは、%{name}さん!'), :name => 'ゆきひろ')
-          end
-        end
-
-        test "interpolation: given a utf-8 translation and a euc-jp value it raises Encoding::CompatibilityError" do
-          assert_raise(Encoding::CompatibilityError) do
-            interpolate(:default => 'こんにちは、%{name}さん!', :name => euc_jp('ゆきひろ'))
-          end
-        end
-
-        test "interpolation: ASCII strings in the backend should be encoded to UTF8 if interpolation options are in UTF8" do
-          I18n.backend.store_translations 'en', 'encoding' => ('%{who} let me go'.force_encoding("ASCII"))
-          result = I18n.t 'encoding', :who => "måmmå miå"
-          assert_equal Encoding::UTF_8, result.encoding
-        end
-
-        test "interpolation: UTF8 strings in the backend are still returned as UTF8 with ASCII interpolation" do
-          I18n.backend.store_translations 'en', 'encoding' => 'måmmå miå %{what}'
-          result = I18n.t 'encoding', :what => 'let me go'.force_encoding("ASCII")
-          assert_equal Encoding::UTF_8, result.encoding
-        end
-
-        test "interpolation: UTF8 strings in the backend are still returned as UTF8 even with numbers interpolation" do
-          I18n.backend.store_translations 'en', 'encoding' => '%{count} times: måmmå miå'
-          result = I18n.t 'encoding', :count => 3
-          assert_equal Encoding::UTF_8, result.encoding
-        end
-      end
-
-      test "interpolation: given a translations containing a reserved key it raises I18n::ReservedInterpolationKey" do
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '%{default}',   :foo => :bar) }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '%{scope}',     :foo => :bar) }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '%{separator}', :foo => :bar) }
-      end
-
-      protected
-
-      def capture(stream)
-        begin
-          stream = stream.to_s
-          eval "$#{stream} = StringIO.new"
-          yield
-          result = eval("$#{stream}").string
-        ensure
-          eval("$#{stream} = #{stream.upcase}")
-        end
-
-        result
-      end
-
-      def euc_jp(string)
-        string.encode!(Encoding::EUC_JP)
-      end
-
-      def interpolate(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        key = args.pop
-        I18n.backend.translate('en', key, options)
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/tests/link.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Tests
-    module Link
-      test "linked lookup: if a key resolves to a symbol it looks up the symbol" do
-        I18n.backend.store_translations 'en', {
-          :link  => :linked,
-          :linked => 'linked'
-        }
-        assert_equal 'linked', I18n.backend.translate('en', :link)
-      end
-
-      test "linked lookup: if a key resolves to a dot-separated symbol it looks up the symbol" do
-        I18n.backend.store_translations 'en', {
-          :link => :"foo.linked",
-          :foo  => { :linked => 'linked' }
-        }
-        assert_equal('linked', I18n.backend.translate('en', :link))
-      end
-
-      test "linked lookup: if a dot-separated key resolves to a symbol it looks up the symbol" do
-        I18n.backend.store_translations 'en', {
-          :foo    => { :link => :linked },
-          :linked => 'linked'
-        }
-        assert_equal('linked', I18n.backend.translate('en', :'foo.link'))
-      end
-      
-      test "linked lookup: if a dot-separated key resolves to a dot-separated symbol it looks up the symbol" do
-        I18n.backend.store_translations 'en', {
-          :foo => { :link   => :"bar.linked" },
-          :bar => { :linked => 'linked' }
-        }
-        assert_equal('linked', I18n.backend.translate('en', :'foo.link'))
-      end
-
-      test "linked lookup: links always refer to the absolute key" do
-        I18n.backend.store_translations 'en', {
-          :foo => { :link => :linked, :linked => 'linked in foo' },
-          :linked => 'linked absolutely'
-        }
-        assert_equal 'linked absolutely', I18n.backend.translate('en', :link, :scope => :foo)
-      end
-
-      test "linked lookup: a link can resolve to a namespace in the middle of a dot-separated key" do
-        I18n.backend.store_translations 'en', {
-          :activemodel  => { :errors => { :messages => { :blank => "can't be blank" } } },
-          :activerecord => { :errors => { :messages => :"activemodel.errors.messages" } }
-        }
-        assert_equal "can't be blank", I18n.t(:"activerecord.errors.messages.blank")
-        assert_equal "can't be blank", I18n.t(:"activerecord.errors.messages.blank")
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/i18n-0.6.1/lib/i18n/tests/localization/date.rb

@@ -1,84 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Tests
-    module Localization
-      module Date
-        def setup
-          super
-          setup_date_translations
-          @date = ::Date.new(2008, 3, 1)
-        end
-
-        test "localize Date: given the short format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal '01. Mar', I18n.l(@date, :format => :short, :locale => :de)
-        end
-
-        test "localize Date: given the long format it uses it" do
-          assert_equal '01. März 2008', I18n.l(@date, :format => :long, :locale => :de)
-        end
-
-        test "localize Date: given the default format it uses it" do
-          assert_equal '01.03.2008', I18n.l(@date, :format => :default, :locale => :de)
-        end
-
-        test "localize Date: given a day name format it returns the correct day name" do
-          assert_equal 'Samstag', I18n.l(@date, :format => '%A', :locale => :de)
-        end
-
-        test "localize Date: given an abbreviated day name format it returns the correct abbreviated day name" do
-          assert_equal 'Sa', I18n.l(@date, :format => '%a', :locale => :de)
-        end
-
-        test "localize Date: given a month name format it returns the correct month name" do
-          assert_equal 'März', I18n.l(@date, :format => '%B', :locale => :de)
-        end
-
-        test "localize Date: given an abbreviated month name format it returns the correct abbreviated month name" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Mar', I18n.l(@date, :format => '%b', :locale => :de)
-        end
-
-        test "localize Date: given an unknown format it does not fail" do
-          assert_nothing_raised { I18n.l(@date, :format => '%x') }
-        end
-
-        test "localize Date: given nil it raises I18n::ArgumentError" do
-          assert_raise(I18n::ArgumentError) { I18n.l(nil) }
-        end
-
-        test "localize Date: given a plain Object it raises I18n::ArgumentError" do
-          assert_raise(I18n::ArgumentError) { I18n.l(Object.new) }
-        end
-
-        test "localize Date: given a format is missing it raises I18n::MissingTranslationData" do
-          assert_raise(I18n::MissingTranslationData) { I18n.l(@date, :format => :missing) }
-        end
-
-        test "localize Date: it does not alter the format string" do
-          assert_equal '01. Februar 2009', I18n.l(::Date.parse('2009-02-01'), :format => :long, :locale => :de)
-          assert_equal '01. Oktober 2009', I18n.l(::Date.parse('2009-10-01'), :format => :long, :locale => :de)
-        end
-
-        protected
-
-          def setup_date_translations
-            I18n.backend.store_translations :de, {
-              :date => {
-                :formats => {
-                  :default => "%d.%m.%Y",
-                  :short => "%d. %b",
-                  :long => "%d. %B %Y",
-                },
-                :day_names => %w(Sonntag Montag Dienstag Mittwoch Donnerstag Freitag Samstag),
-                :abbr_day_names => %w(So Mo Di Mi Do Fr  Sa),
-                :month_names => %w(Januar Februar März April Mai Juni Juli August September Oktober November Dezember).unshift(nil),
-                :abbr_month_names => %w(Jan Feb Mar Apr Mai Jun Jul Aug Sep Okt Nov Dez).unshift(nil)
-              }
-            }
-          end
-      end
-    end
-  end
-end