ruby-cldr 0.0.2 → 0.1.0

data/lib/cldr/export/data/rbnf_root.rb

@@ -0,0 +1,19 @@
+module Cldr
+  module Export
+    module Data
+      class RbnfRoot < Rbnf
+
+        def initialize
+          super(nil)
+        end
+
+        private
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/rbnf/root.xml"
+        end
+
+      end
+    end
+  end
+end

data/lib/cldr/export/data/timezones.rb

@@ -6,21 +6,44 @@ module Cldr
       class Timezones < Base
         def initialize(locale)
           super
-          update(:timezones => timezones)
+          update(:timezones => timezones, :metazones => metazones)
         end
 
         def timezones
           @timezones ||= select('dates/timeZoneNames/zone').inject({}) do |result, zone|
-            type = zone.attribute('type').value.to_sym
-            city = select(zone, 'exemplarCity').first
+            type = zone.attr('type').to_sym
             result[type] = {}
-            # see en.xml, Europe/London, does not have an exemplarCity element
-            # instead it has long and short daylight names which otherwise only
-            # have metazones. (??)
+            long = nodes_to_hash(zone.xpath('long/*'))
+            result[type][:long] = long unless long.empty?
+            short = nodes_to_hash(zone.xpath('short/*'))
+            result[type][:short] = short unless short.empty?
+            city = select(zone, 'exemplarCity').first
             result[type][:city] = city.content if city
             result
           end
         end
+
+        def metazones
+          @metazones ||= select('dates/timeZoneNames/metazone').inject({}) do |result, zone|
+            type = zone.attr('type').to_sym
+            result[type] = {}
+            long = nodes_to_hash(zone.xpath('long/*'))
+            result[type][:long] = long unless long.empty?
+            short = nodes_to_hash(zone.xpath('short/*'))
+            result[type][:short] = short unless short.empty?
+            result
+          end
+        end
+
+        protected
+
+        def nodes_to_hash(nodes)
+          nodes.inject({}) do |result, node|
+            result[node.name.to_sym] = node.content
+            result
+          end
+        end
+
       end
     end
   end

data/lib/cldr/export/data/units.rb

@@ -4,11 +4,23 @@ module Cldr
       class Units < Base
         def initialize(locale)
           super
-          update(:units => units)
+          update(
+            :units => {
+              :unitLength => unitLength,
+              :durationUnit => durationUnit,
+            }
+          )
         end
 
-        def units
-          select('units/unit').inject({}) do |result, node|
+        def unitLength
+          select('units/unitLength').inject({}) do |result, node|
+            result[node.attribute('type').value.to_sym] = units(node)
+            result
+          end
+        end
+
+        def units(node)
+          node.xpath('unit').inject({}) do |result, node|
             result[node.attribute('type').value.to_sym] = unit(node)
             result
           end
@@ -16,10 +28,15 @@ module Cldr
 
         def unit(node)
           node.xpath('unitPattern').inject({}) do |result, node|
-            alt = node.attribute('alt') ? node.attribute('alt').value.to_sym : :default
             count = node.attribute('count') ? node.attribute('count').value.to_sym : :one
-            result[alt] ||= {}
-            result[alt][count] = node.content unless draft?(node)
+            result[count] = node.content unless draft?(node)
+            result
+          end
+        end
+
+        def durationUnit
+          select('units/durationUnit').inject({}) do |result, node|
+            result[node.attribute('type').value.to_sym] = node.xpath('durationUnitPattern').first.content
             result
           end
         end

data/lib/cldr/export/data/windows_zones.rb

@@ -0,0 +1,23 @@
+require 'nokogiri'
+require 'time'
+
+module Cldr
+  module Export
+    module Data
+      class WindowsZones < Hash
+        def initialize
+          path = "#{Cldr::Export::Data.dir}/supplemental/windowsZones.xml"
+          doc = File.open(path) { |file| Nokogiri::XML(file) }
+          doc.xpath('//windowsZones/mapTimezones/mapZone').inject(self) do |result, node|
+            zone = node.attr('other').to_s
+            territory = node.attr('territory')
+            timezones = node.attr('type').split(' ')
+            result[zone] ||= {}
+            result[zone][territory] = timezones
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/yaml.rb

@@ -10,7 +10,8 @@ module Cldr
       def export(locale, component, options = {})
         data = Export.data(component, locale, options)
         unless data.empty?
-          data = { locale.to_s.gsub('_', '-') => data }.deep_stringify_keys
+          data = data.deep_stringify_keys if data.respond_to?(:deep_stringify_keys)
+          data = { locale.to_s.gsub('_', '-') => data } if locale != ""
           path = Export.path(locale, component, 'yml')
           Export.write(path, yaml(data))
           yield(component, locale, path) if block_given?

data/lib/cldr/format/datetime/base.rb

@@ -23,7 +23,7 @@ module Cldr
           def compile_format(format)
             "'" + format.gsub(self.class.const_get(:PATTERN)) do |token|
               method = self.class.const_get(:METHODS)[token[0, 1]]
-              "' + #{method}(date, #{token.inspect}, #{token.length}) + '"
+              "' + #{method}(date, #{token.inspect}, #{token.length}).to_s + '"
             end + "'"
           end
       end

data/lib/cldr/format/time.rb

@@ -18,7 +18,7 @@ module Cldr
       }
 
       def period(time, pattern, length)
-        calendar[:periods][time.strftime('%p').downcase.to_sym]
+        calendar[:periods][:format][:wide][time.strftime('%p').downcase.to_sym]
       end
 
       def hour(time, pattern, length)

data/lib/cldr/thor.rb

@@ -5,7 +5,7 @@ module Cldr
   class Thor < ::Thor
     namespace 'cldr'
 
-    desc "download [--source=http://unicode.org/Public/cldr/2.0.1/core.zip] [--target=./vendor]",
+    desc "download [--source=http://unicode.org/Public/cldr/24/core.zip] [--target=./vendor]",
          "Download and extract CLDR data from source to target dir"
     method_options %w(source -s) => :string,
                    %w(target -t) => :string

data/lib/core_ext/string/camelize.rb

@@ -1,5 +1,5 @@
 class String
   def camelize
-    self.gsub(/(^.{1}|[^a-z0-9])/) { $1.capitalize }
+    self.gsub(/(^.|_[a-zA-Z])/) { |m| m.sub("_",'').capitalize }
   end
 end unless String.new.respond_to?(:camelize)

data/test/export/data/calendars_test.rb

@@ -13,13 +13,13 @@ class TestCldrDataCalendars < Test::Unit::TestCase
     months = {
       :format  => {
         :wide        => { 1 => 'Januar', 2 => 'Februar', 3 => 'März', 4 => 'April', 5 => 'Mai', 6 => 'Juni', 7 => 'Juli', 8 => 'August', 9 => 'September', 10 => 'Oktober', 11 => 'November', 12 => 'Dezember' },
-        :abbreviated => { 1 => 'Jan', 2 => 'Feb', 3 => 'Mär', 4 => 'Apr', 5 => 'Mai', 6 => 'Jun', 7 => 'Jul', 8 => 'Aug', 9 => 'Sep', 10 => 'Okt', 11 => 'Nov', 12 => 'Dez' },
-        :narrow      => :"calendars.gregorian.months.stand-alone.narrow"
+        :abbreviated => { 1 => 'Jan.', 2 => 'Feb.', 3 => 'März', 4 => 'Apr.', 5 => 'Mai', 6 => 'Juni', 7 => 'Juli', 8 => 'Aug.', 9 => 'Sep.', 10 => 'Okt.', 11 => 'Nov.', 12 => 'Dez.' },
+        :narrow      => { 1 => 'J', 2 => 'F', 3 => 'M', 4 => 'A', 5 => 'M', 6 => 'J', 7 => 'J', 8 => 'A', 9 => 'S', 10 => 'O', 11 => 'N', 12 => 'D' },
       },
       :'stand-alone' => {
-        :abbreviated => { 3 => 'Mär', 7 => 'Jul', 8 => 'Aug', 9 => 'Sep', 10 => 'Okt', 11 => 'Nov', 12 => 'Dez' },
+        :abbreviated => { 1 => 'Jan', 2 => 'Feb', 3 => 'Mär', 4 => 'Apr', 5 => 'Mai', 6 => 'Jun', 7 => 'Jul', 8 => 'Aug', 9 => 'Sep', 10 => 'Okt', 11 => 'Nov', 12 => 'Dez'},
         :narrow      => { 1 => 'J', 2 => 'F', 3 => 'M', 4 => 'A', 5 => 'M', 6 => 'J', 7 => 'J', 8 => 'A', 9 => 'S', 10 => 'O', 11 => 'N', 12 => 'D' },
-        :wide        => :"calendars.gregorian.months.format.wide"
+        :wide        => { 1 => 'Januar', 2 => 'Februar', 3 => 'März', 4 => 'April', 5 => 'Mai', 6 => 'Juni', 7 => 'Juli', 8 => 'August', 9 => 'September', 10 => 'Oktober', 11 => 'November', 12 => 'Dezember' },
       }
     }
     assert_equal months, gregorian[:months]
@@ -30,12 +30,14 @@ class TestCldrDataCalendars < Test::Unit::TestCase
       :format  => {
         :wide        => { :sun => 'Sonntag', :mon => 'Montag', :tue => 'Dienstag', :wed => 'Mittwoch', :thu => 'Donnerstag', :fri => 'Freitag', :sat => 'Samstag' },
         :abbreviated => { :sun => 'So.', :mon => 'Mo.', :tue => 'Di.', :wed => 'Mi.', :thu => 'Do.', :fri => 'Fr.', :sat => 'Sa.' },
-        :narrow      => :"calendars.gregorian.days.stand-alone.narrow"
+        :narrow      => { :sun => 'S', :mon => 'M', :tue => 'D', :wed => 'M', :thu => 'D', :fri => 'F', :sat => 'S' },
+        :short       => { :sun => 'So.', :mon => 'Mo.', :tue => 'Di.', :wed => 'Mi.', :thu => 'Do.', :fri => 'Fr.', :sat => 'Sa.' }
       },
       :'stand-alone' => {
-        :abbreviated => :"calendars.gregorian.days.format.abbreviated",
+        :abbreviated => { :sun => 'So', :mon => 'Mo', :tue => 'Di', :wed => 'Mi', :thu => 'Do', :fri => 'Fr', :sat => 'Sa' },
         :narrow      => { :sun => 'S', :mon => 'M', :tue => 'D', :wed => 'M', :thu => 'D', :fri => 'F', :sat => 'S' },
-        :wide        => :"calendars.gregorian.days.format.wide"
+        :short       => { :sun => 'So.', :mon => 'Mo.', :tue => 'Di.', :wed => 'Mi.', :thu => 'Do.', :fri => 'Fr.', :sat => 'Sa.' },
+        :wide        => { :sun => 'Sonntag', :mon => 'Montag', :tue => 'Dienstag', :wed => 'Mittwoch', :thu => 'Donnerstag', :fri => 'Freitag', :sat => 'Samstag' },
       }
     }
     assert_equal days, gregorian[:days]
@@ -45,13 +47,13 @@ class TestCldrDataCalendars < Test::Unit::TestCase
     quarters = {
       :format  => {
         :wide        => { 1 => "1. Quartal", 2 => "2. Quartal", 3 => "3. Quartal", 4 => "4. Quartal" },
-        :narrow      => :"calendars.gregorian.quarters.stand-alone.narrow",
+        :narrow      => { 1 => "1", 2 => "2", 3 => "3", 4 => "4" },
         :abbreviated => { 1 => "Q1", 2 => "Q2", 3 => "Q3", 4 => "Q4" }
       },
       :"stand-alone" => {
-        :abbreviated => :"calendars.gregorian.quarters.format.abbreviated",
+        :abbreviated => { 1 => "Q1", 2 => "Q2", 3 => "Q3", 4 => "Q4" },
         :narrow      => { 1 => "1", 2 => "2", 3 => "3", 4 => "4" },
-        :wide        =>:"calendars.gregorian.quarters.format.wide"
+        :wide        => { 1 => "1. Quartal", 2 => "2. Quartal", 3 => "3. Quartal", 4 => "4. Quartal" }
       }
     }
     assert_equal quarters, gregorian[:quarters]
@@ -59,10 +61,16 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars periods :de' do
     periods = {
-      :am => 'vorm.',
-      :pm => 'nachm.',
+      :afternoon => "nachmittags",
+      :am => "vorm.",
+      :earlyMorning => "morgens",
+      :evening => "abends",
+      :morning => "vormittags",
+      :night => "nachts",
+      :noon => "Mittag",
+      :pm => "nachm."
     }
-    assert_equal periods, gregorian[:periods]
+    assert_equal periods, gregorian[:periods][:format][:wide]
   end
 
   # root.xml
@@ -88,10 +96,9 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars date formats :de' do
     formats = {
-      :default => :"calendars.gregorian.formats.date.medium",
       :full    => { :pattern => "EEEE, d. MMMM y" },
       :long    => { :pattern => "d. MMMM y" },
-      :medium  => { :pattern => "dd.MM.yyyy" },
+      :medium  => { :pattern => "dd.MM.y" },
       :short   => { :pattern => "dd.MM.yy" }
     }
     assert_equal formats, gregorian[:formats][:date]
@@ -99,7 +106,6 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars time formats :de' do
     formats = {
-      :default => :"calendars.gregorian.formats.time.medium",
       :full    => { :pattern => "HH:mm:ss zzzz" },
       :long    => { :pattern => "HH:mm:ss z" },
       :medium  => { :pattern => "HH:mm:ss" },
@@ -110,7 +116,6 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars datetime formats :de' do
     formats = {
-      :default => :"calendars.gregorian.formats.datetime.medium",
       :full    => { :pattern => "{{date}} {{time}}"},
       :long    => { :pattern => "{{date}} {{time}}"},
       :medium  => { :pattern => "{{date}} {{time}}"},
@@ -131,7 +136,7 @@ class TestCldrDataCalendars < Test::Unit::TestCase
       :weekday   => "Wochentag",
       :dayperiod => "Tageshälfte",
       :era       => "Epoche",
-      :zone      => "Zone"
+      :zone      => "Zeitzone"
     }
     assert_equal fields, gregorian[:fields]
   end

data/test/export/data/currencies_test.rb

@@ -7,32 +7,32 @@ class TestCldrCurrencies < Test::Unit::TestCase
     codes = [:ADP, :AED, :AFA, :AFN, :ALL, :AMD, :ANG, :AOA, :AOK, :AON, :AOR,
              :ARA, :ARP, :ARS, :ATS, :AUD, :AWG, :AZM, :AZN, :BAD, :BAM, :BBD,
              :BDT, :BEC, :BEF, :BEL, :BGL, :BGN, :BHD, :BIF, :BMD, :BND, :BOB,
-             :BOP, :BOV, :BRB, :BRC, :BRE, :BRL, :BRN, :BRR, :BSD, :BTN, :BUK,
-             :BWP, :BYB, :BYR, :BZD, :CAD, :CDF, :CHE, :CHF, :CHW, :CLF, :CLP,
-             :CNY, :COP, :COU, :CRC, :CSD, :CSK, :CUP, :CVE, :CYP, :CZK, :DDM,
-             :DEM, :DJF, :DKK, :DOP, :DZD, :ECS, :ECV, :EEK, :EGP, :ERN, :ESA,
-             :ESB, :ESP, :ETB, :EUR, :FIM, :FJD, :FKP, :FRF, :GBP, :GEK, :GEL,
-             :GHC, :GHS, :GIP, :GMD, :GNF, :GNS, :GQE, :GRD, :GTQ, :GWE, :GWP,
-             :GYD, :HKD, :HNL, :HRD, :HRK, :HTG, :HUF, :IDR, :IEP, :ILP, :ILS,
-             :INR, :IQD, :IRR, :ISK, :ITL, :JMD, :JOD, :JPY, :KES, :KGS, :KHR,
-             :KMF, :KPW, :KRW, :KWD, :KYD, :KZT, :LAK, :LBP, :LKR, :LRD, :LSL,
-             :LTL, :LTT, :LUC, :LUF, :LUL, :LVL, :LVR, :LYD, :MAD, :MAF, :MDL,
-             :MGA, :MGF, :MKD, :MLF, :MMK, :MNT, :MOP, :MRO, :MTL, :MTP, :MUR,
-             :MVR, :MWK, :MXN, :MXP, :MXV, :MYR, :MZE, :MZM, :MZN, :NAD, :NGN,
-             :NIC, :NIO, :NLG, :NOK, :NPR, :NZD, :OMR, :PAB, :PEI, :PEN, :PES,
-             :PGK, :PHP, :PKR, :PLN, :PLZ, :PTE, :PYG, :QAR, :RHD, :ROL, :RON,
-             :RSD, :RUB, :RUR, :RWF, :SAR, :SBD, :SCR, :SDD, :SDG, :SDP, :SEK,
-             :SGD, :SHP, :SIT, :SKK, :SLL, :SOS, :SRD, :SRG, :STD, :SUR, :SVC,
-             :SYP, :SZL, :THB, :TJR, :TJS, :TMM, :TND, :TOP, :TPE, :TRL, :TRY,
-             :TTD, :TWD, :TZS, :UAH, :UAK, :UGS, :UGX, :USD, :USN, :USS, :UYI,
-             :UYP, :UYU, :UZS, :VEB, :VEF, :VND, :VUV, :WST, :XAF, :XAG, :XAU,
-             :XBA, :XBB, :XBC, :XBD, :XCD, :XDR, :XEU, :XFO, :XFU, :XOF, :XPD,
-             :XPF, :XPT, :XRE, :XTS, :XXX, :YDD, :YER, :YUD, :YUM, :YUN, :ZAL,
-             :ZAR, :ZMK, :ZRN, :ZRZ, :ZWD]
-    
+             :BOP, :BOV, :BRB, :BRC, :BRE, :BRL, :BRN, :BRR, :BRZ, :BSD, :BTN,
+             :BUK, :BWP, :BYB, :BYR, :BZD, :CAD, :CDF, :CHE, :CHF, :CHW, :CLF,
+             :CLP, :CNY, :COP, :CRC, :CSD, :CSK, :CUC, :CUP, :CVE, :CYP, :CZK,
+             :DDM, :DEM, :DJF, :DKK, :DOP, :DZD, :ECS, :ECV, :EEK, :EGP, :ERN,
+             :ESA, :ESB, :ESP, :ETB, :EUR, :FIM, :FJD, :FKP, :FRF, :GBP, :GEK,
+             :GEL, :GHC, :GHS, :GIP, :GMD, :GNF, :GNS, :GQE, :GRD, :GTQ, :GWE,
+             :GWP, :GYD, :HKD, :HNL, :HRD, :HRK, :HTG, :HUF, :IDR, :IEP, :ILP,
+             :ILS, :INR, :IQD, :IRR, :ISK, :ITL, :JMD, :JOD, :JPY, :KES, :KGS,
+             :KHR, :KMF, :KPW, :KRW, :KWD, :KYD, :KZT, :LAK, :LBP, :LKR, :LRD,
+             :LSL, :LTL, :LTT, :LUC, :LUF, :LUL, :LVL, :LVR, :LYD, :MAD, :MAF,
+             :MDL, :MGA, :MGF, :MKD, :MLF, :MMK, :MNT, :MOP, :MRO, :MTL, :MTP,
+             :MUR, :MVR, :MWK, :MXN, :MXP, :MXV, :MYR, :MZE, :MZM, :MZN, :NAD,
+             :NGN, :NIC, :NIO, :NLG, :NOK, :NPR, :NZD, :OMR, :PAB, :PEI, :PEN,
+             :PES, :PGK, :PHP, :PKR, :PLN, :PLZ, :PTE, :PYG, :QAR, :RHD, :ROL,
+             :RON, :RSD, :RUB, :RUR, :RWF, :SAR, :SBD, :SCR, :SDD, :SDG, :SDP,
+             :SEK, :SGD, :SHP, :SIT, :SKK, :SLL, :SOS, :SRD, :SRG, :SSP, :STD,
+             :SUR, :SVC, :SYP, :SZL, :THB, :TJR, :TJS, :TMM, :TMT, :TND, :TOP,
+             :TPE, :TRL, :TRY, :TTD, :TWD, :TZS, :UAH, :UAK, :UGS, :UGX, :USD,
+             :USN, :USS, :UYP, :UYU, :UZS, :VEB, :VEF, :VND, :VUV, :WST, :XAF,
+             :XAG, :XAU, :XBA, :XBB, :XBC, :XBD, :XCD, :XDR, :XEU, :XFO, :XFU,
+             :XOF, :XPD, :XPF, :XPT, :XRE, :XTS, :XXX, :YDD, :YER, :YUD, :YUM,
+             :YUN, :ZAL, :ZAR, :ZMK, :ZMW, :ZRN, :ZRZ, :ZWD, :ZWL, :ZWR]
+
     currencies = Cldr::Export::Data::Currencies.new('de')[:currencies]
     assert (currencies.keys - codes).empty? && (codes - currencies.keys).empty?
-    assert_equal({ :one => 'Euro', :other => 'Euro' }, currencies[:EUR])
+    assert_equal({ :one => 'Euro', :other => 'Euro', :symbol => '€' }, currencies[:EUR])
   end
 
   # Cldr::Export::Data.locales.each do |locale|

data/test/export/data/languages_test.rb

@@ -4,58 +4,62 @@ require File.expand_path(File.join(File.dirname(__FILE__) + '/../../test_helper'
 
 class TestCldrDataLanguages < Test::Unit::TestCase
   test 'languages :de' do
-    codes = [:aa, :ab, :ace, :ach, :ada, :ady, :ae, :af, :afa, :afh, :ain,
-             :ak, :akk, :ale, :alg, :alt, :am, :an, :ang, :anp, :apa, :ar,
-             :arc, :arn, :arp, :art, :arw, :as, :ast, :ath, :aus, :av, :awa,
-             :ay, :az, :ba, :bad, :bai, :bal, :ban, :bas, :bat, :be, :bej,
-             :bem, :ber, :bg, :bh, :bho, :bi, :bik, :bin, :bla, :bm, :bn, :bnt,
-             :bo, :br, :bra, :bs, :btk, :bua, :bug, :byn, :ca, :cad, :cai,
-             :car, :cau, :cch, :ce, :ceb, :cel, :ch, :chb, :chg, :chk, :chm,
-             :chn, :cho, :chp, :chr, :chy, :cmc, :co, :cop, :cpe, :cpf, :cpp,
-             :cr, :crh, :crp, :cs, :csb, :cu, :cus, :cv, :cy, :da, :dak, :dar,
-             :day, :de, :"de-AT", :"de-CH", :del, :den, :dgr, :din, :doi, :dra,
-             :dsb, :dua, :dum, :dv, :dyu, :dz, :ee, :efi, :egy, :eka, :el,
-             :elx, :en, :"en-AU", :"en-CA", :"en-GB", :"en-US", :enm, :eo, :es,
-             :"es-419", :"es-ES", :et, :eu, :ewo, :fa, :fan, :fat, :ff, :fi,
-             :fil, :fiu, :fj, :fo, :fon, :fr, :"fr-CA", :"fr-CH", :frm, :fro,
-             :frr, :frs, :fur, :fy, :ga, :gaa, :gay, :gba, :gd, :gem, :gez,
-             :gil, :gl, :gmh, :gn, :goh, :gon, :gor, :got, :grb, :grc, :gsw,
-             :gu, :gv, :gwi, :ha, :hai, :haw, :he, :hi, :hil, :him, :hit, :hmn,
-             :ho, :hr, :hsb, :ht, :hu, :hup, :hy, :hz, :ia, :iba, :id, :ie,
-             :ig, :ii, :ijo, :ik, :ilo, :inc, :ine, :inh, :io, :ira, :iro, :is,
-             :it, :iu, :ja, :jbo, :jpr, :jrb, :jv, :ka, :kaa, :kab, :kac, :kaj,
-             :kam, :kar, :kaw, :kbd, :kcg, :kfo, :kg, :kha, :khi, :kho, :ki,
-             :kj, :kk, :kl, :km, :kmb, :kn, :ko, :kok, :kos, :kpe, :kr, :krc,
-             :krl, :kro, :kru, :ks, :ku, :kum, :kut, :kv, :kw, :ky, :la, :lad,
-             :lah, :lam, :lb, :lez, :lg, :li, :ln, :lo, :lol, :loz, :lt, :lu,
-             :lua, :lui, :lun, :luo, :lus, :lv, :mad, :mag, :mai, :mak, :man,
-             :map, :mas, :mdf, :mdr, :men, :mg, :mga, :mh, :mi, :mic, :min,
-             :mis, :mk, :mkh, :ml, :mn, :mnc, :mni, :mno, :mo, :moh, :mos, :mr,
-             :ms, :mt, :mul, :mun, :mus, :mwl, :mwr, :my, :myn, :myv, :na,
-             :nah, :nai, :nap, :nb, :nd, :nds, :ne, :new, :ng, :nia, :nic,
-             :niu, :nl, :"nl-BE", :nn, :no, :nog, :non, :nqo, :nr, :nso, :nub,
-             :nv, :nwc, :ny, :nym, :nyn, :nyo, :nzi, :oc, :oj, :om, :or, :os,
-             :osa, :ota, :oto, :pa, :paa, :pag, :pal, :pam, :pap, :pau, :peo,
-             :phi, :phn, :pi, :pl, :pon, :pra, :pro, :ps, :pt, :"pt-BR",
-             :"pt-PT", :qu, :raj, :rap, :rar, :rm, :rn, :ro, :roa, :rom, :root,
-             :ru, :rup, :rw, :sa, :sad, :sah, :sai, :sal, :sam, :sas, :sat,
-             :sc, :scn, :sco, :sd, :se, :sel, :sem, :sg, :sga, :sgn, :sh, :shn,
-             :si, :sid, :sio, :sit, :sk, :sl, :sla, :sm, :sma, :smi, :smj,
-             :smn, :sms, :sn, :snk, :so, :sog, :son, :sq, :sr, :srn, :srr, :ss,
-             :ssa, :st, :su, :suk, :sus, :sux, :sv, :sw, :syc, :syr, :ta, :tai,
-             :te, :tem, :ter, :tet, :tg, :th, :ti, :tig, :tiv, :tk, :tkl, :tl,
-             :tlh, :tli, :tmh, :tn, :to, :tog, :tpi, :tr, :ts, :tsi, :tt, :tum,
-             :tup, :tut, :tvl, :tw, :ty, :tyv, :udm, :ug, :uga, :uk, :umb,
-             :und, :ur, :uz, :vai, :ve, :vi, :vo, :vot, :wa, :wak, :wal, :war,
-             :was, :wen, :wo, :xal, :xh, :yao, :yap, :yi, :yo, :ypk, :za, :zap,
-             :zbl, :zen, :zh, :"zh-Hans", :"zh-Hant", :znd, :zu, :zun, :zxx, :zza]
-    
+    codes = [:aa, :ab, :ace, :ach, :ada, :ady, :ae, :af, :afa, :afh, :agq,
+             :ain, :ak, :akk, :ale, :alg, :alt, :am, :an, :ang, :anp, :apa,
+             :ar, :"ar-001", :arc, :arn, :arp, :art, :arw, :as, :asa, :ast,
+             :ath, :aus, :av, :awa, :ay, :az, :ba, :bad, :bai, :bal, :ban,
+             :bas, :bat, :bax, :bbj, :be, :bej, :bem, :ber, :bez, :bfd, :bg,
+             :bh, :bho, :bi, :bik, :bin, :bkm, :bla, :bm, :bn, :bnt, :bo, :br,
+             :bra, :brx, :bs, :bss, :btk, :bua, :bug, :bum, :byn, :byv, :ca,
+             :cad, :cai, :car, :cau, :cay, :cch, :ce, :ceb, :cel, :cgg, :ch,
+             :chb, :chg, :chk, :chm, :chn, :cho, :chp, :chr, :chy, :ckb, :cmc,
+             :co, :cop, :cpe, :cpf, :cpp, :cr, :crh, :crp, :cs, :csb, :cu,
+             :cus, :cv, :cy, :da, :dak, :dar, :dav, :day, :de, :"de-AT",
+             :"de-CH", :del, :den, :dgr, :din, :dje, :doi, :dra, :dsb, :dua,
+             :dum, :dv, :dyo, :dyu, :dz, :dzg, :ebu, :ee, :efi, :egy, :eka,
+             :el, :elx, :en, :"en-AU", :"en-CA", :"en-GB", :"en-US", :enm, :eo,
+             :es, :"es-419", :"es-ES", :"es-MX", :et, :eu, :ewo, :fa, :fan,
+             :fat, :ff, :fi, :fil, :fiu, :fj, :fo, :fon, :fr, :"fr-CA", :"fr-CH",
+             :frm, :fro, :frr, :frs, :fur, :fy, :ga, :gaa, :gay, :gba, :gd, :gem,
+             :gez, :gil, :gl, :gmh, :gn, :goh, :gon, :gor, :got, :grb, :grc,
+             :gsw,  :gu, :guz, :gv, :gwi, :ha, :hai, :haw, :he, :hi, :hil, :him,
+             :hit,  :hmn, :ho, :hr, :hsb, :ht, :hu, :hup, :hy, :hz, :ia, :iba,
+             :ibb, :id, :ie, :ig, :ii, :ijo, :ik, :ilo, :inc, :ine, :inh, :io,
+             :ira,  :iro, :is, :it, :iu, :ja, :jbo, :jmc, :jpr, :jrb, :jv, :ka,
+             :kaa,  :kab, :kac, :kaj, :kam, :kar, :kaw, :kbd, :kbl, :kcg, :kde,
+             :kea, :kfo, :kg, :kha, :khi, :kho, :khq, :ki, :kj, :kk, :kkj, :kl,
+             :kln, :km, :kmb, :kn, :ko, :kok, :kos, :kpe, :kr, :krc, :krl, :kro,
+             :kru, :ks, :ksb, :ksf, :ksh, :ku, :kum, :kut, :kv, :kw, :ky, :la,
+             :lad, :lag, :lah, :lam, :lb, :lez, :lg, :li, :ln, :lo, :lol, :loz,
+             :lt, :lu, :lua, :lui, :lun, :luo, :lus, :luy, :lv, :mad, :maf, :mag,
+             :mai, :mak, :man, :map, :mas, :mde, :mdf, :mdr, :men, :mer, :mfe,
+             :mg, :mga, :mgh, :mh, :mi, :mic, :min, :mis, :mk, :mkh, :ml, :mn,
+             :mnc, :mni, :mno, :mo, :moh, :mos, :mr, :ms, :mt, :mua, :mul, :mun,
+             :mus, :mwl, :mwr, :my, :mye, :myn, :myv, :na, :nah, :nai, :nap, :naq,
+             :nb, :nd, :nds, :ne, :new, :ng, :nia, :nic, :niu, :nl, :"nl-BE", :nmg,
+             :nn, :nnh, :no, :nog, :non, :nqo, :nr, :nso, :nub, :nus, :nv, :nwc,
+             :ny, :nym, :nyn, :nyo, :nzi, :oc, :oj, :om,  :or, :os, :osa, :ota,
+             :oto, :pa, :paa, :pag, :pal, :pam, :pap, :pau, :peo, :phi, :phn, :pi,
+             :pl, :pon, :pra, :pro, :ps, :pt, :"pt-BR", :"pt-PT", :qu, :raj, :rap,
+             :rar, :rm, :rn, :ro, :roa, :rof, :rom,  :root, :ru, :rup, :rw, :rwk,
+             :sa, :sad, :sah, :sai, :sal, :sam,  :saq, :sas, :sat, :sba, :sbp, :sc,
+             :scn, :sco, :sd, :se, :see, :seh, :sel, :sem, :ses, :sg, :sga, :sgn,
+             :sh, :shi, :shn, :shu, :si, :sid, :sio, :sit, :sk, :sl, :sla, :sm,
+             :sma, :smi, :smj, :smn, :sms, :sn, :snk, :so, :sog, :son, :sq, :sr,
+             :srn, :srr, :ss, :ssa, :ssy, :st,  :su, :suk, :sus, :sux, :sv, :sw,
+             :swb, :swc, :syc, :syr, :ta, :tai, :te, :tem, :teo, :ter, :tet, :tg,
+             :th, :ti, :tig, :tiv, :tk, :tkl, :tl, :tlh, :tli, :tmh, :tn, :to, :tog,
+             :tpi, :tr, :trv, :ts, :tsi,  :tt, :tum, :tup, :tut, :tvl, :tw, :twq,
+             :ty, :tyv, :tzm, :udm, :ug, :uga, :uk, :umb, :und, :ur, :uz, :vai, :ve,
+             :vi, :vo, :vot, :vun, :wa, :wae, :wak, :wal, :war, :was, :wen, :wo, :xal,
+             :xh, :xog, :yao, :yap, :yav, :ybb, :yi, :yo, :ypk, :yue, :za, :zap, :zbl,
+             :zen, :zgh, :zh, :"zh-Hans", :"zh-Hant", :znd, :zu, :zun, :zxx, :zza]
+
     languages = Cldr::Export::Data::Languages.new('de')[:languages]
-  
     assert (languages.keys - codes).empty? && (codes - languages.keys).empty?
     assert_equal('Deutsch', languages[:de])
   end
-  
+
   # Cldr::Export::Data.locales.each do |locale|
   #   test "extract languages for #{locale}" do
   #     assert_nothing_raised do