ruby-cldr 0.1.0 → 0.5.0

data/test/export/data/calendars_test.rb

@@ -11,33 +11,49 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars months :de' do
     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ä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' },
+      :format => {
+        :abbreviated => { 1 => 'Jan.', 2 => 'Feb.', 3 => 'März', 4 => 'Apr.', 5 => 'Mai', 6 => 'Juni', 7 => 'Juli', 8 => 'Aug.', 9 => 'Sept.', 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 => { 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' },
       },
       :'stand-alone' => {
-        :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        => { 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 => { 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 => { 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]
   end
 
+  test 'calendars months :en' do
+    months = {
+      :format => {
+        :abbreviated => { 1 => "Jan", 2 => "Feb", 3 => "Mar", 4 => "Apr", 5 => "May", 6 => "Jun", 7 => "Jul", 8 => "Aug", 9 => "Sep", 10 => "Oct", 11 => "Nov", 12 => "Dec" },
+        :narrow => :"calendars.gregorian.months.stand-alone.narrow",
+        :wide => { 1 => "January", 2 => "February", 3 => "March", 4 => "April", 5 => "May", 6 => "June", 7 => "July", 8 => "August", 9 => "September", 10 => "October", 11 => "November", 12 => "December" },
+      },
+      :"stand-alone" => {
+        :abbreviated => :"calendars.gregorian.months.format.abbreviated",
+        :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",
+      },
+    }
+    assert_equal months, gregorian(locale: :en)[:months]
+  end
+
   test 'calendars days :de' do
     days = {
-      :format  => {
-        :wide        => { :sun => 'Sonntag', :mon => 'Montag', :tue => 'Dienstag', :wed => 'Mittwoch', :thu => 'Donnerstag', :fri => 'Freitag', :sat => 'Samstag' },
+      :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      => { :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.' }
+        :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 => { :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' },
-        :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' },
+        :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.' },
+        :wide => { :sun => 'Sonntag', :mon => 'Montag', :tue => 'Dienstag', :wed => 'Mittwoch', :thu => 'Donnerstag', :fri => 'Freitag', :sat => 'Samstag' },
       }
     }
     assert_equal days, gregorian[:days]
@@ -45,15 +61,15 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars quarters :de' do
     quarters = {
-      :format  => {
-        :wide        => { 1 => "1. Quartal", 2 => "2. Quartal", 3 => "3. Quartal", 4 => "4. Quartal" },
-        :narrow      => { 1 => "1", 2 => "2", 3 => "3", 4 => "4" },
+      :format => {
+        :wide => { 1 => "1. Quartal", 2 => "2. Quartal", 3 => "3. Quartal", 4 => "4. Quartal" },
+        :narrow => { 1 => "1", 2 => "2", 3 => "3", 4 => "4" },
         :abbreviated => { 1 => "Q1", 2 => "Q2", 3 => "Q3", 4 => "Q4" }
       },
       :"stand-alone" => {
         :abbreviated => { 1 => "Q1", 2 => "Q2", 3 => "Q3", 4 => "Q4" },
-        :narrow      => { 1 => "1", 2 => "2", 3 => "3", 4 => "4" },
-        :wide        => { 1 => "1. Quartal", 2 => "2. Quartal", 3 => "3. Quartal", 4 => "4. Quartal" }
+        :narrow => { 1 => "1", 2 => "2", 3 => "3", 4 => "4" },
+        :wide => { 1 => "1. Quartal", 2 => "2. Quartal", 3 => "3. Quartal", 4 => "4. Quartal" }
       }
     }
     assert_equal quarters, gregorian[:quarters]
@@ -61,14 +77,15 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars periods :de' do
     periods = {
-      :afternoon => "nachmittags",
-      :am => "vorm.",
-      :earlyMorning => "morgens",
-      :evening => "abends",
-      :morning => "vormittags",
-      :night => "nachts",
-      :noon => "Mittag",
-      :pm => "nachm."
+      :afternoon1=>"mittags",
+      :afternoon2=>"nachmittags",
+      :am=>"AM",
+      :evening1=>"abends",
+      :midnight=>"Mitternacht",
+      :morning1=>"morgens",
+      :morning2=>"vormittags",
+      :night1=>"nachts",
+      :pm=>"PM",
     }
     assert_equal periods, gregorian[:periods][:format][:wide]
   end
@@ -96,51 +113,84 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   test 'calendars date formats :de' do
     formats = {
-      :full    => { :pattern => "EEEE, d. MMMM y" },
-      :long    => { :pattern => "d. MMMM y" },
-      :medium  => { :pattern => "dd.MM.y" },
-      :short   => { :pattern => "dd.MM.yy" }
+      :full => { :pattern => "EEEE, d. MMMM y" },
+      :long => { :pattern => "d. MMMM y" },
+      :medium => { :pattern => "dd.MM.y" },
+      :short => { :pattern => "dd.MM.yy" }
     }
     assert_equal formats, gregorian[:formats][:date]
   end
 
   test 'calendars time formats :de' do
     formats = {
-      :full    => { :pattern => "HH:mm:ss zzzz" },
-      :long    => { :pattern => "HH:mm:ss z" },
-      :medium  => { :pattern => "HH:mm:ss" },
-      :short   => { :pattern => "HH:mm" }
+      :full => { :pattern => "HH:mm:ss zzzz" },
+      :long => { :pattern => "HH:mm:ss z" },
+      :medium => { :pattern => "HH:mm:ss" },
+      :short => { :pattern => "HH:mm" }
     }
     assert_equal formats, gregorian[:formats][:time]
   end
 
   test 'calendars datetime formats :de' do
     formats = {
-      :full    => { :pattern => "{{date}} {{time}}"},
-      :long    => { :pattern => "{{date}} {{time}}"},
-      :medium  => { :pattern => "{{date}} {{time}}"},
-      :short   => { :pattern => "{{date}} {{time}}"}
+      :full => { :pattern => "{{date}} 'um' {{time}}" },
+      :long => { :pattern => "{{date}} 'um' {{time}}" },
+      :medium => { :pattern => "{{date}}, {{time}}" },
+      :short => { :pattern => "{{date}}, {{time}}" }
     }
     assert_equal formats, gregorian[:formats][:datetime]
   end
 
   test 'calendars fields :de' do
-    fields = {
-      :hour      => "Stunde",
-      :minute    => "Minute",
-      :second    => "Sekunde",
-      :day       => "Tag",
-      :month     => "Monat",
-      :year      => "Jahr",
-      :week      => "Woche",
-      :weekday   => "Wochentag",
+    fields = { :day => "Tag",
+      :"day-narrow" => "Tag",
+      :"day-short" => "Tag",
+      :dayOfYear => "Tag des Jahres",
+      :"dayOfYear-narrow" => "T/J",
+      :"dayOfYear-short" => "Tag des Jahres",
       :dayperiod => "Tageshälfte",
-      :era       => "Epoche",
-      :zone      => "Zeitzone"
+      :"dayperiod-narrow" => "Tagesh.",
+      :"dayperiod-short" => "Tageshälfte",
+      :era => "Epoche",
+      :"era-narrow" => "E",
+      :"era-short" => "Epoche",
+      :hour => "Stunde",
+      :"hour-narrow" => "Std.",
+      :"hour-short" => "Std.",
+      :minute => "Minute",
+      :"minute-narrow" => "Min.",
+      :"minute-short" => "Min.",
+      :month => "Monat",
+      :"month-narrow" => "M",
+      :"month-short" => "Monat",
+      :quarter => "Quartal",
+      :"quarter-narrow" => "Q",
+      :"quarter-short" => "Quart.",
+      :second => "Sekunde",
+      :"second-narrow" => "Sek.",
+      :"second-short" => "Sek.",
+      :week => "Woche",
+      :"week-narrow" => "W",
+      :"week-short" => "Woche",
+      :weekOfMonth => "Woche des Monats",
+      :"weekOfMonth-narrow" => "Wo. des Monats",
+      :"weekOfMonth-short" => "W/M",
+      :weekday => "Wochentag",
+      :"weekday-narrow" => "Wochent.",
+      :"weekday-short" => "Wochentag",
+      :weekdayOfMonth => "Wochentag",
+      :"weekdayOfMonth-narrow" => "WT",
+      :"weekdayOfMonth-short" => "Wochentag",
+      :year => "Jahr",
+      :"year-narrow" => "J",
+      :"year-short" => "Jahr",
+      :zone => "Zeitzone",
+      :"zone-narrow" => "Zeitz.",
+      :"zone-short" => "Zeitzone",
     }
     assert_equal fields, gregorian[:fields]
   end
-  
+
   test 'merged calendars for de-AT contains all date format and stand-alone name types' do
     assert_equal %w(abbreviated narrow wide), gregorian(:merged => true)[:months][:format].keys.map { |key| key.to_s }.sort
     assert_equal %w(abbreviated narrow wide), gregorian(:merged => true)[:months][:"stand-alone"].keys.map { |key| key.to_s }.sort

data/test/export/data/country_codes_test.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require File.expand_path(File.join(File.dirname(__FILE__) + '/../../test_helper'))
+
+class TestCldrDataCountryCodes < Test::Unit::TestCase
+  test 'country codes' do
+    expected =
+      {
+        AA: {
+          "numeric" => "958",
+          "alpha3" => "AAA",
+        },
+        AC: {
+          "alpha3" => "ASC",
+        }
+      }
+    country_codes = Cldr::Export::Data::CountryCodes.new
+    assert_equal(country_codes[:country_codes][:AA], expected[:AA])
+    assert_equal(country_codes[:country_codes][:AC], expected[:AC])
+  end
+end

data/test/export/data/currencies_test.rb

@@ -5,34 +5,48 @@ require File.expand_path(File.join(File.dirname(__FILE__) + '/../../test_helper'
 class TestCldrCurrencies < Test::Unit::TestCase
   test 'currencies :de' do
     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, :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]
+      :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, :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, :ALK,
+      :ARL, :ARM, :BAN, :BGM, :BGO, :BOL, :CLE, :CNX, :COU, :ILR, :ISJ,
+      :KRH, :KRO, :MCF, :MDC, :MKN, :MVP, :UYI, :VNN, :XSU, :XUA, :YUR,
+      :BYN, :CNH, :MRU, :STN, :VES]
 
     currencies = Cldr::Export::Data::Currencies.new('de')[:currencies]
-    assert (currencies.keys - codes).empty? && (codes - currencies.keys).empty?
-    assert_equal({ :one => 'Euro', :other => 'Euro', :symbol => '€' }, currencies[:EUR])
+    assert_empty codes - currencies.keys, "Unexpected missing currencies"
+    assert_empty currencies.keys - codes, "Unexpected extra currencies"
+    assert_equal({ :name => 'Euro', :'narrow_symbol'=>'€', :one => 'Euro', :other => 'Euro', :symbol => '€' }, currencies[:EUR])
+  end
+
+  test 'currencies populates symbol-narrow when narrow symbol is not equal to the regular symbol' do
+    currencies = Cldr::Export::Data::Currencies.new('root')[:currencies]
+    assert_equal({ :symbol=>'US$', :'narrow_symbol'=>'$'}, currencies[:USD])
+  end
+
+  test 'currencies uses the label to populate :one when count is unavailable' do
+    currencies = Cldr::Export::Data::Currencies.new('ak')[:currencies]
+    assert_equal({ :name => 'Yuan', :one => 'Yuan' }, currencies[:CNY])
   end
 
   # Cldr::Export::Data.locales.each do |locale|

data/test/export/data/languages_test.rb

@@ -4,62 +4,80 @@ 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, :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]
+    codes = [:aa, :ab, :ace, :ach, :ada, :ady, :ae, :aeb, :af,
+      :afh, :agq, :ain, :ak, :akk, :akz, :ale, :aln, :alt, :am,
+      :an, :ang, :anp, :ar, :"ar-001", :arc, :arn, :aro, :arp,
+      :arq, :ars, :arw, :ary, :arz, :as, :asa, :ase, :ast, :av,
+      :avk, :awa, :ay, :az, :ba, :bal, :ban, :bar, :bas, :bax,
+      :bbc, :bbj, :be, :bej, :bem, :bew, :bez, :bfd, :bfq, :bg,
+      :bgn, :bho, :bi, :bik, :bin, :bjn, :bkm, :bla, :bm, :bn,
+      :bo, :bpy, :bqi, :br, :bra, :brh, :brx, :bs, :bss, :bua,
+      :bug, :bum, :byn, :byv, :ca, :cad, :car, :cay, :cch, :ce,
+      :ceb, :cgg, :ch, :chb, :chg, :chk, :chm, :chn, :cho, :chp,
+      :chr, :chy, :ckb, :co, :cop, :cps, :cr, :crh, :crs, :cs,
+      :csb, :cu, :cv, :cy, :da, :dak, :dar, :dav, :de, :"de-AT",
+      :"de-CH", :del, :den, :dgr, :din, :dje, :doi, :dsb, :dtp,
+      :dua, :dum, :dv, :dyo, :dyu, :dz, :dzg, :ebu, :ee, :efi,
+      :egl, :egy, :eka, :el, :elx, :en, :enm,
+      :eo, :es, :esu, :et, :eu, :ewo, :ext, :fa, :fan, :fat, :ff,
+      :fi, :fil, :fit, :fj, :fo, :fon, :fr, :frc, :frm, :fro,
+      :frp, :frr, :frs, :fur, :fy, :ga, :gaa, :gag, :gan, :gay,
+      :gba, :gbz, :gd, :gez, :gil, :gl, :glk, :gmh, :gn, :goh,
+      :gom, :gon, :gor, :got, :grb, :grc, :gsw, :gu, :guc, :gur,
+      :guz, :gv, :gwi, :ha, :hai, :hak, :haw, :he, :hi, :hif,
+      :hil, :hit, :hmn, :ho, :hr, :hsb, :hsn, :ht, :hu, :hup,
+      :hy, :hz, :ia, :iba, :ibb, :id, :ie, :ig, :ii, :ik, :ilo,
+      :inh, :io, :is, :it, :iu, :izh, :ja, :jam, :jbo, :jgo,
+      :jmc, :jpr, :jrb, :jut, :jv, :ka, :kaa, :kab, :kac,
+      :kaj, :kam, :kaw, :kbd, :kbl, :kcg, :kde, :kea, :ken,
+      :kfo, :kg, :kgp, :kha, :kho, :khq, :khw, :ki, :kiu, :kj,
+      :kk, :kkj, :kl, :kln, :km, :kmb, :kn, :ko, :koi, :kok,
+      :kos, :kpe, :kr, :krc, :kri, :krj, :krl, :kru, :ks, :ksb,
+      :ksf, :ksh, :ku, :kum, :kut, :kv, :kw, :ky, :la, :lad,
+      :lag, :lah, :lam, :lb, :lez, :lfn, :lg, :li, :lij, :liv,
+      :lkt, :lmo, :ln, :lo, :lol, :lou, :loz, :lrc, :lt, :ltg,
+      :lu, :lua, :lui, :lun, :luo, :lus, :luy, :lv, :lzh, :lzz,
+      :mad, :maf, :mag, :mai, :mak, :man, :mas, :mde, :mdf, :mdr,
+      :men, :mer, :mfe, :mg, :mga, :mgh, :mgo, :mh, :mi, :mic,
+      :min, :mk, :ml, :mn, :mnc, :mni, :moh, :mos, :mr, :mrj, :ms,
+      :mt, :mua, :mul, :mus, :mwl, :mwr, :mwv, :my, :mye, :myv,
+      :mzn, :na, :nan, :nap, :naq, :nb, :nd, :nds, :"nds-NL", :ne,
+      :new, :ng, :nia, :niu, :njo, :nl, :"nl-BE", :nmg, :nn, :nnh,
+      :no, :nog, :non, :nov, :nqo, :nr, :nso, :nus, :nv, :nwc, :ny,
+      :nym, :nyn, :nyo, :nzi, :oc, :oj, :om, :or, :os, :osa, :ota,
+      :pa, :pag, :pal, :pam, :pap, :pau, :pcd, :pcm, :pdc, :pdt,
+      :peo, :pfl, :phn, :pi, :pl, :pms, :pnt, :pon, :prg, :pro,
+      :ps, :pt, :qu, :quc, :qug, :raj, :rap, :rar, :rgn, :rif, :rm,
+      :rn, :ro, :"ro-MD", :rof, :rom, :root, :rtm, :ru, :rue, :rug,
+      :rup, :rw, :rwk, :sa, :sad, :sah, :sam, :saq, :sas, :sat, :saz,
+      :sba, :sbp, :sc, :scn, :sco, :sd, :sdc, :sdh, :se, :see, :seh,
+      :sei, :sel, :ses, :sg, :sga, :sgs, :sh, :shi, :shn, :shu, :si,
+      :sid, :sk, :sl, :sli, :sly, :sm, :sma, :smj, :smn, :sms, :sn,
+      :snk, :so, :sog, :sq, :sr, :srn, :srr, :ss, :ssy, :st, :stq,
+      :su, :suk, :sus, :sux, :sv, :sw, :"sw-CD", :swb, :syc, :syr,
+      :szl, :ta, :tcy, :te, :tem, :teo, :ter, :tet, :tg, :th, :ti,
+      :tig, :tiv, :tk, :tkl, :tkr, :tl, :tlh, :tli, :tly, :tmh,
+      :tn, :to, :tog, :tpi, :tr, :tru, :trv, :ts, :tsd, :tsi, :tt,
+      :ttt, :tum, :tvl, :tw, :twq, :ty, :tyv, :tzm, :udm, :ug, :uga,
+      :uk, :umb, :und, :ur, :uz, :vai, :ve, :vec, :vep, :vi, :vls,
+      :vmf, :vo, :vot, :vro, :vun, :wa, :wae, :wal, :war, :was,
+      :wbp, :wo, :wuu, :xal, :xh, :xmf, :xog, :yao, :yap, :yav,
+      :ybb, :yi, :yo, :yrl, :yue, :za, :zap, :zbl, :zea, :zen,
+      :zgh, :zh, :"zh-Hans", :"zh-Hant", :zu, :zun, :zxx, :zza]
 
     languages = Cldr::Export::Data::Languages.new('de')[:languages]
-    assert (languages.keys - codes).empty? && (codes - languages.keys).empty?
+
+    assert_empty codes - languages.keys, "Unexpected missing languages"
+    assert_empty languages.keys - codes, "Unexpected extra languages"
     assert_equal('Deutsch', languages[:de])
   end
 
+  test 'languages does not overwrite long form with the short one' do
+    languages = Cldr::Export::Data::Languages.new(:en)[:languages]
+
+    assert_equal "American English", languages[:"en-US"]
+  end
+
   # Cldr::Export::Data.locales.each do |locale|
   #   test "extract languages for #{locale}" do
   #     assert_nothing_raised do

data/test/export/data/numbers_test.rb

@@ -5,83 +5,82 @@ require File.expand_path(File.join(File.dirname(__FILE__) + '/../../test_helper'
 class TestCldrDataNumbers < Test::Unit::TestCase
   test "number symbols :de" do
     expected = {
-      :nan               => "NaN",
-      :decimal           => ",",
-      :plus_sign         => "+",
-      :minus_sign        => "-",
-      :group             => ".",
-      :exponential       => "E",
-      :percent_sign      => "%",
-      :list              => ";",
-      :per_mille         => "‰",
-      :infinity          => "∞",
-      :superscripting_exponent => "·"
+      :decimal => ",",
+      :exponential => "E",
+      :group => ".",
+      :infinity => "∞",
+      :list => ";",
+      :minus_sign => "-",
+      :nan => "NaN",
+      :per_mille => "‰",
+      :percent_sign => "%",
+      :plus_sign => "+",
+      :superscripting_exponent => "·",
+      :time_separator => ":",
     }
     assert_equal expected, Cldr::Export::Data::Numbers.new('de')[:numbers][:symbols]
   end
 
   test "number formats :de" do
     expected = {
+      :currency => {
+        :number_system => "latn",
+        :patterns => {
+          :default => "#,##0.00 ¤",
+          "short" => {
+            "1000" => { "one" => "0", "other" => "0" },
+            "10000" => { "one" => "0", "other" => "0" },
+            "100000" => { "one" => "0", "other" => "0" },
+            "1000000" => { "one" => "0 Mio'.' ¤", "other" => "0 Mio'.' ¤" },
+            "10000000" => { "one" => "00 Mio'.' ¤", "other" => "00 Mio'.' ¤" },
+            "100000000" => { "one" => "000 Mio'.' ¤", "other" => "000 Mio'.' ¤" },
+            "1000000000" => { "one" => "0 Mrd'.' ¤", "other" => "0 Mrd'.' ¤" },
+            "10000000000" => { "one" => "00 Mrd'.' ¤", "other" => "00 Mrd'.' ¤" },
+            "100000000000" => { "one" => "000 Mrd'.' ¤", "other" => "000 Mrd'.' ¤" },
+            "1000000000000" => { "one" => "0 Bio'.' ¤", "other" => "0 Bio'.' ¤" },
+            "10000000000000" => { "one" => "00 Bio'.' ¤", "other" => "00 Bio'.' ¤" },
+            "100000000000000" => { "one" => "000 Bio'.' ¤", "other" => "000 Bio'.' ¤" } } },
+        :unit => { "one" => "{0} {1}", "other" => "{0} {1}" } },
       :decimal => {
         :number_system => "latn",
         :patterns => {
           :default => "#,##0.###",
           "long" => {
-            "1000" => "0 Tausend",
-            "10000" => "00 Tausend",
-            "100000" => "000 Tausend",
-            "1000000" => "0 Millionen",
-            "10000000" => "00 Millionen",
-            "100000000" => "000 Millionen",
-            "1000000000" => "0 Milliarden",
-            "10000000000" => "00 Milliarden",
-            "100000000000" => "000 Milliarden",
-            "1000000000000" => "0 Billionen",
-            "10000000000000" => "00 Billionen",
-            "100000000000000" => "000 Billionen"
-          },
+            "1000" => { "one" => "0 Tausend", "other" => "0 Tausend" },
+            "10000" => { "one" => "00 Tausend", "other" => "00 Tausend" },
+            "100000" => { "one" => "000 Tausend", "other" => "000 Tausend" },
+            "1000000" => { "one" => "0 Million", "other" => "0 Millionen" },
+            "10000000" => { "one" => "00 Millionen", "other" => "00 Millionen" },
+            "100000000" => { "one" => "000 Millionen", "other" => "000 Millionen" },
+            "1000000000" => { "one" => "0 Milliarde", "other" => "0 Milliarden" },
+            "10000000000" => { "one" => "00 Milliarden", "other" => "00 Milliarden" },
+            "100000000000" => { "one" => "000 Milliarden", "other" => "000 Milliarden" },
+            "1000000000000" => { "one" => "0 Billion", "other" => "0 Billionen" },
+            "10000000000000" => { "one" => "00 Billionen", "other" => "00 Billionen" },
+            "100000000000000" => { "one" => "000 Billionen", "other" => "000 Billionen" } },
           "short" => {
-            "1000" => "0 Tsd",
-            "10000" => "00 Tsd",
-            "100000" => "000 Tsd",
-            "1000000" => "0 Mio",
-            "10000000" => "00 Mio",
-            "100000000" => "000 Mio",
-            "1000000000" => "0 Mrd",
-            "10000000000" => "00 Mrd",
-            "100000000000" => "000 Mrd",
-            "1000000000000" => "0 Bio",
-            "10000000000000" => "00 Bio",
-            "100000000000000" => "000 Bio"
-          }
-        }
-      },
-      :scientific => {
-        :number_system => "latn",
-        :patterns => {
-          :default => "#E0"
-        }
-      },
-      :percent => {
-        :number_system => "latn",
-        :patterns => {
-          :default => "#,##0 %"     # includes a non-breaking space (\302\240)
-        }
-      },
-      :currency => {
-        :number_system => "latn",
-        :patterns => {
-          :default => "#,##0.00 ¤", # includes a non-breaking space (\302\240)
-        },
-        :unit => {
-          "one"   => "{0} {1}",
-          "other" => "{0} {1}"
-        }
-      }
-    }
+            "1000" => { "one" => "0", "other" => "0" },
+            "10000" => { "one" => "0", "other" => "0" },
+            "100000" => { "one" => "0", "other" => "0" },
+            "1000000" => { "one" => "0 Mio'.'", "other" => "0 Mio'.'" },
+            "10000000" => { "one" => "00 Mio'.'", "other" => "00 Mio'.'" },
+            "100000000" => { "one" => "000 Mio'.'", "other" => "000 Mio'.'" },
+            "1000000000" => { "one" => "0 Mrd'.'", "other" => "0 Mrd'.'" },
+            "10000000000" => { "one" => "00 Mrd'.'", "other" => "00 Mrd'.'" },
+            "100000000000" => { "one" => "000 Mrd'.'", "other" => "000 Mrd'.'" },
+            "1000000000000" => { "one" => "0 Bio'.'", "other" => "0 Bio'.'" },
+            "10000000000000" => { "one" => "00 Bio'.'", "other" => "00 Bio'.'" },
+            "100000000000000" => { "one" => "000 Bio'.'", "other" => "000 Bio'.'" } } } },
+      :percent => { :number_system => "latn", :patterns => { :default => "#,##0 %" } },
+      :scientific => { :number_system => "latn", :patterns => { :default => "#E0" } } }
     assert_equal expected, Cldr::Export::Data::Numbers.new('de')[:numbers][:formats]
   end
 
+  test "redirects in root locale" do
+    assert_equal :"numbers.formats.decimal.patterns.short",
+      Cldr::Export::Data::Numbers.new('root')[:numbers][:formats][:decimal][:patterns]['long']
+  end
+
   # Cldr::Export::Data.locales.each do |locale|
   #   test "extract number_symbols for #{locale}" do
   #     assert_nothing_raised do