ruby-cldr 0.1.1 → 0.2.0

data/lib/cldr/export/data/transforms.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+module Cldr
+  module Export
+    module Data
+      class Transforms < Base
+
+        attr_reader :transform_file
+
+        def initialize(transform_file)
+          super(nil)  # no locale
+          @transform_file = transform_file
+          update(:transforms => transforms)
+        end
+
+        private
+
+        def transforms
+          doc.xpath("supplementalData/transforms/transform").map do |transform_node|
+            {
+              :source => transform_node.attribute("source").value,
+              :target => transform_node.attribute("target").value,
+              :variant => get_variant(transform_node),
+              :direction => transform_node.attribute("direction").value,
+              :rules => rules(transform_node)
+            }
+          end
+        end
+
+        def get_variant(node)
+          if attrib = node.attribute("variant")
+            attrib.value
+          end
+        end
+
+        def rules(transform_node)
+          rules = fix_rule_wrapping(
+            doc.xpath("#{transform_node.path}/tRule").flat_map do |rule_node|
+              fix_rule(rule_node.content).split("\n").map(&:strip)
+            end
+          )
+
+          rules.reject do |rule|
+            rule.strip.empty? || rule.strip.start_with?('#')
+          end
+        end
+
+        def fix_rule_wrapping(rules)
+          wrap = false
+
+          rules.each_with_object([]) do |rule, ret|
+            if wrap
+              ret.last.sub!(/\\\z/, rule)
+            else
+              ret << rule
+            end
+
+            wrap = rule.end_with?('\\')
+          end
+        end
+
+        def fix_rule(rule)
+          rule.
+            gsub("←", '<').
+            gsub("→", '>').
+            gsub("↔", '<>')
+        end
+
+        def path
+          transform_file
+        end
+
+      end
+    end
+  end
+end

data/lib/cldr/export/data/variables.rb

@@ -0,0 +1,42 @@
+module Cldr
+  module Export
+    module Data
+      class Variables < Base
+
+        # only these variables will be exported
+        VARIABLE_IDS = %w($grandfathered $language $territory $script $variant)
+
+        def initialize
+          super(nil)
+          update(:variables => variables)
+        end
+
+        private
+
+        def variables
+          doc.xpath('//validity/variable').inject({}) do |ret, variable|
+            name = variable.attribute('id').value
+            if VARIABLE_IDS.include?(name)
+              ret[fix_var_name(name)] = split_value_list(variable.text)
+            end
+            ret
+          end
+        end
+
+        def fix_var_name(var_name)
+          # remove leading dollar sign
+          var_name.sub(/\A\$/, '')
+        end
+
+        def split_value_list(value_list)
+          value_list.strip.split(/[\s]+/)
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/supplemental/supplementalMetadata.xml"
+        end
+
+      end
+    end
+  end
+end

data/lib/cldr/export/yaml.rb

@@ -1,11 +1,8 @@
-require 'ya2yaml'
+require 'yaml'
 
 module Cldr
   module Export
-    class Yaml < Ya2YAML
-      def initialize
-        super(:syck_compatible => true)
-      end
+    class Yaml
 
       def export(locale, component, options = {})
         data = Export.data(component, locale, options)
@@ -19,22 +16,9 @@ module Cldr
         end
       end
 
-    	def yaml(data)
-    		emit(data, 1)[1..-1]
-    	end
-
-    	def emit(object, level = 1)
-    		result = object.is_a?(Symbol) ? object.inspect : super
-    		result.gsub(/(\s{1})(no):/i) { %(#{$1}"#{$2}":) } # FIXME fucking spaghetti code
-    	end
-
-    	def is_one_plain_line?(str)
-    		# removed REX_BOOL, REX_INT
-    		str !~ /^([\-\?:,\[\]\{\}\#&\*!\|>'"%@`\s]|---|\.\.\.)/    &&
-    		str !~ /[:\#\s\[\]\{\},]/                                  &&
-    		str !~ /#{REX_ANY_LB}/                                     &&
-    		str !~ /^(#{REX_FLOAT}|#{REX_MERGE}|#{REX_NULL}|#{REX_TIMESTAMP}|#{REX_VALUE})$/x
-    	end
+      def yaml(data)
+         data.to_yaml
+      end
     end
   end
 end

data/lib/cldr/thor.rb

@@ -5,7 +5,7 @@ module Cldr
   class Thor < ::Thor
     namespace 'cldr'
 
-    desc "download [--source=http://unicode.org/Public/cldr/24/core.zip] [--target=./vendor]",
+    desc "download [--source=http://unicode.org/Public/cldr/26/core.zip] [--target=./vendor]",
          "Download and extract CLDR data from source to target dir"
     method_options %w(source -s) => :string,
                    %w(target -t) => :string
@@ -27,7 +27,7 @@ module Cldr
       Cldr::Export.export(options.dup.symbolize_keys) { putc '.' }
       puts
     end
-  
+
     # TODO flatten task, e.g. flatten all plural locale files into one big file
   end
 end

data/test/export/data/calendars_test.rb

@@ -11,15 +11,15 @@ 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]
@@ -27,17 +27,17 @@ class TestCldrDataCalendars < Test::Unit::TestCase
 
   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 +45,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 +61,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 +97,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/currencies_test.rb

@@ -5,33 +5,37 @@ 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_empty codes - currencies.keys, "Unexpected missing currencies"
+    assert_empty currencies.keys - codes, "Unexpected extra currencies"
     assert_equal({ :one => 'Euro', :other => 'Euro', :symbol => '€' }, currencies[:EUR])
   end
 

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, :"en-GB", :"en-US", :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