ruby-cldr 0.0.1

data/lib/cldr/format/time.rb

@@ -0,0 +1,71 @@
+class Cldr
+  module Format
+    class Time < Datetime::Base
+      PATTERN = /a{1}|h{1,2}|H{1,2}|K{1,2}|k{1,2}|m{1,2}|s{1,2}|S+|z{1,4}|Z{1,4}/
+      METHODS = { # ignoring u, l, g, j, A
+        'a' => :period,
+        'h' => :hour,
+        'H' => :hour,
+        'K' => :hour,
+        'k' => :hour,
+        'm' => :minute,
+        's' => :second,
+        'S' => :second_fraction,
+        'z' => :timezone,
+        'Z' => :timezone,
+        'v' => :timezone_generic_non_location,
+        'V' => :timezone_metazone
+      }
+
+      def period(time, pattern, length)
+        calendar[:periods][time.strftime('%p').downcase.to_sym]
+      end
+
+      def hour(time, pattern, length)
+        hour = time.hour
+        hour = case pattern[0, 1]
+        when 'h' # [1-12]
+          hour > 12 ? (hour - 12) : (hour == 0 ? 12 : hour)
+        when 'H' # [0-23]
+          hour
+        when 'K' # [0-11]
+          hour > 11 ? hour - 12 : hour
+        when 'k' # [1-24]
+          hour == 0 ? 24 : hour
+        end
+        length == 1 ? hour.to_s : hour.to_s.rjust(length, '0')
+      end
+
+      def minute(time, pattern, length)
+        length == 1 ? time.min.to_s : time.min.to_s.rjust(length, '0')
+      end
+
+      def second(time, pattern, length)
+        length == 1 ? time.sec.to_s : time.sec.to_s.rjust(length, '0')
+      end
+
+      def second_fraction(time, pattern, length)
+        raise 'can not use the S format with more than 6 digits' if length > 6
+        (time.usec.to_f / 10 ** (6 - length)).round.to_s.rjust(length, '0')
+      end
+
+      def timezone(time, pattern, length)
+        case length
+        when 1..3
+          time.zone
+        else
+          raise 'not yet implemented (requires timezone translation data")'
+        end
+      end
+
+      def timezone_generic_non_location(time, pattern, length)
+        raise 'not yet implemented (requires timezone translation data")'
+      end
+
+      def round_to(number, precision)
+        factor = 10 ** precision
+        (number * factor).round.to_f / factor
+      end
+    end
+  end
+end

data/lib/cldr/format.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+require 'core_ext/string/camelize'
+
+class Cldr
+  module Format
+    autoload :Base,     'cldr/format/base'
+    autoload :Currency, 'cldr/format/currency'
+    autoload :Fraction, 'cldr/format/fraction'
+    autoload :Integer,  'cldr/format/integer'
+    autoload :Date,     'cldr/format/date'
+    autoload :Datetime, 'cldr/format/datetime'
+    autoload :Decimal,  'cldr/format/decimal'
+    autoload :Numeric,  'cldr/format/numeric'
+    autoload :Percent,  'cldr/format/percent'
+    autoload :Time,     'cldr/format/time'
+
+    def format(locale, object, options = {})
+      type = options.has_key?(:currency) ? :currency : options.delete(:as)
+      type ||= guess_type(object)
+
+      send(:"format_#{type}", locale, object, options)
+    end
+
+    def format_decimal(locale, number, options = {})
+      formatter(locale, :decimal, options.delete(:format)).apply(number, options)
+    end
+    alias :format_number :format_decimal
+
+    def format_integer(locale, number, options = {})
+      format_number(number, options.merge(:precision => 0))
+    end
+    alias :format_int :format_integer
+
+    def format_currency(locale, number, options = {})
+      if options[:currency].is_a?(Symbol)
+        options.merge!(:currency => lookup_currency(locale, options[:currency], number))
+      end
+      formatter(locale, :currency, options.delete(:format)).apply(number, options)
+    end
+
+    def format_percent(locale, number, options = {})
+      formatter(locale, :percent, options.delete(:format)).apply(number, options)
+    end
+
+    def format_date(locale, date, options = {})
+      formatter(locale, :date, options.delete(:format)).apply(date, options)
+    end
+
+    def format_time(locale, time, options = {})
+      formatter(locale, :time, options.delete(:format)).apply(time, options)
+    end
+
+    def format_datetime(locale, datetime, options = {})
+      format = options.delete(:format) || :default
+      (@formatters ||= {})[:"#{locale}.datetime.#{format}"] ||= begin
+        date = formatter(locale, :date, options.delete(:date_format) || format)
+        time = formatter(locale, :time, options.delete(:time_format) || format)
+        format = lookup_format(locale, :datetime, format)
+        Cldr::Format::Datetime.new(format, date, time).apply(datetime, options)
+      end
+    end
+
+    protected
+
+      def guess_type(object)
+        case object
+        when ::Numeric
+          :number
+        when ::Date, ::DateTime, ::Time
+          object.class.name.downcase
+        else
+          raise_unspecified_format_type!
+        end
+      end
+
+      def formatter(locale, type, format)
+        (@formatters ||= {})[:"#{locale}.#{type}.#{format}"] ||= begin
+          format = lookup_format(locale, type, format)
+          data   = lookup_format_data(locale, type)
+          Cldr::Format.const_get(type.to_s.camelize).new(format, data)
+        end
+      end
+
+      def lookup_format(locale, type, format)
+        # Lookup the format string for the given type (e.g. :number).
+        raise_abstract!
+      end
+
+      def lookup_format_data(locale, type)
+        # Lookup the format data required for the given type (e.g. number
+        # symbols for type :number, calendar data for type :date etc.).
+        raise_abstract!
+      end
+
+      def lookup_currency(locale, currency, count)
+        # Lookup the currency representation for the given locale and amount.
+        # This might be a translation.
+        raise_abstract!
+      end
+
+      def raise_unspecified_format_type!
+        raise ArgumentError.new("You have to specify a format type, e.g. :as => :number.")
+      end
+
+      def raise_unspecified_currency!
+        raise ArgumentError.new("You have to specify a currency, e.g. :currency => 'EUR'.")
+      end
+
+      def raise_abstract!
+        raise "you have to implement this method"
+      end
+  end
+end

data/lib/cldr/thor.rb

@@ -0,0 +1,33 @@
+require 'thor'
+require 'cldr'
+
+class Cldr
+  class Thor < ::Thor
+    namespace 'cldr'
+
+    desc "download [--source=http://unicode.org/Public/cldr/1.7.2/core.zip] [--target=./vendor]",
+         "Download and extract CLDR data from source to target dir"
+    method_options %w(source -s) => :string,
+                   %w(target -t) => :string
+
+    def download
+      require 'cldr/download'
+      Cldr.download(options['source'], options['target'])
+    end
+
+    desc "export [--locales=de fr en] [--components=numbers plurals] [--target=./data] [--merge]",
+         "Export CLDR data by locales and components to target dir"
+    method_options %w(locales -l)    => :array,
+                   %w(components -l) => :array,
+                   %w(target  -t)    => :string,
+                   %w(merge   -m)    => :boolean
+
+    def export
+      $stdout.sync
+      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/lib/cldr.rb

@@ -0,0 +1,7 @@
+require 'core_ext/hash/symbolize_keys'
+
+class Cldr
+  autoload :Data,   'cldr/data'
+  autoload :Export, 'cldr/export'
+  autoload :Format, 'cldr/format'
+end

data/lib/core_ext/hash/deep_merge.rb

@@ -0,0 +1,7 @@
+class Hash
+  def deep_merge(other)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : (v2 || v1) }
+    merge(other, &merger)
+  end
+end
+ 

data/lib/core_ext/hash/deep_stringify_keys.rb

@@ -0,0 +1,11 @@
+class Hash
+  def deep_stringify_keys
+    inject({}) { |result, (key, value)|
+      value = value.deep_stringify_keys if value.is_a?(Hash)
+      key = key.to_s if key.is_a?(Symbol)
+      result[key] = value
+      result
+    }
+  end
+end
+ 

data/lib/core_ext/hash/symbolize_keys.rb

@@ -0,0 +1,10 @@
+class Hash
+  def symbolize_keys
+    inject({}) { |result, (key, value)|
+      key = key.to_sym if key.respond_to?(:to_sym)
+      result[key] = value
+      result
+    }
+  end
+end
+ 

data/lib/core_ext/string/camelize.rb

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

data/lib/core_ext/string/underscore.rb

@@ -0,0 +1,9 @@
+class String
+   def underscore
+     to_s.gsub(/::/, '/').
+       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+       gsub(/([a-z\d])([A-Z])/,'\1_\2').
+       tr("-", "_").
+       downcase
+   end
+end unless String.new.respond_to?(:underscore)

data/test/all.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/**/*_test.rb"].each do |filename|
+  require filename
+end

data/test/data/all.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/**/*_test.rb"].each do |filename|
+  require filename
+end

data/test/data/calendars_test.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+require 'core_ext/hash/deep_stringify_keys'
+
+class TestCldrDataCalendars < Test::Unit::TestCase
+  def gregorian(options = {})
+    locale = options[:locale] || :de
+    Cldr::Export.data(:calendars, locale, options)[:calendars][:gregorian]
+  end
+
+  define_method '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ä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"
+      },
+      :'stand-alone' => {
+        :abbreviated => { 3 => 'Mär', 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"
+      }
+    }
+    assert_equal months, gregorian[:months]
+  end
+
+  define_method 'test: calendars days :de' do
+    days = {
+      :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"
+      },
+      :'stand-alone' => {
+        :abbreviated => :"calendars.gregorian.days.format.abbreviated",
+        :narrow      => { :sun => 'S', :mon => 'M', :tue => 'D', :wed => 'M', :thu => 'D', :fri => 'F', :sat => 'S' },
+        :wide        => :"calendars.gregorian.days.format.wide"
+      }
+    }
+    assert_equal days, gregorian[:days]
+  end
+
+  define_method 'test: calendars quarters :de' do
+    quarters = {
+      :format  => {
+        :wide        => { 1 => "1. Quartal", 2 => "2. Quartal", 3 => "3. Quartal", 4 => "4. Quartal" },
+        :narrow      => :"calendars.gregorian.quarters.stand-alone.narrow",
+        :abbreviated => { 1 => "Q1", 2 => "Q2", 3 => "Q3", 4 => "Q4" }
+      },
+      :"stand-alone" => {
+        :abbreviated => :"calendars.gregorian.quarters.format.abbreviated",
+        :narrow      => { 1 => "1", 2 => "2", 3 => "3", 4 => "4" },
+        :wide        =>:"calendars.gregorian.quarters.format.wide"
+      }
+    }
+    assert_equal quarters, gregorian[:quarters]
+  end
+
+  define_method 'test: calendars periods :de' do
+    periods = {
+      :am => 'vorm.',
+      :pm => 'nachm.',
+    }
+    assert_equal periods, gregorian[:periods]
+  end
+
+  # root.xml
+  # <eras>
+  #   <eraNames>
+  #     <alias source="locale" path="../eraAbbr"/>
+  #   </eraNames>
+  #   <eraAbbr>
+  #     <era type="0">BCE</era>
+  #     <era type="1">CE</era>
+  #   </eraAbbr>
+  #   <eraNarrow>
+  #     <alias source="locale" path="../eraAbbr"/>
+  #   </eraNarrow>
+  # </eras>
+  # define_method 'test: calendars eras :de' do
+  #   eras = {
+  #     0 => { :abbr => "v. Chr.", :name => "v. Chr." },
+  #     1 => { :abbr => "n. Chr.", :name => "n. Chr." }
+  #   }
+  #   assert_equal eras, gregorian[:eras]
+  # end
+
+  define_method '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" },
+      :short   => { :pattern => "dd.MM.yy" }
+    }
+    assert_equal formats, gregorian[:formats][:date]
+  end
+
+  define_method '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" },
+      :short   => { :pattern => "HH:mm" }
+    }
+    assert_equal formats, gregorian[:formats][:time]
+  end
+
+  define_method 'test: calendars datetime formats :de' do
+    formats = {
+      :default => :"calendars.gregorian.formats.datetime.medium",
+      :full    => { :pattern => "{1} {0}"},
+      :long    => { :pattern => "{1} {0}"},
+      :medium  => { :pattern => "{1} {0}"},
+      :short   => { :pattern => "{1} {0}"}
+    }
+    assert_equal formats, gregorian[:formats][:datetime]
+  end
+
+  define_method 'test: calendars fields :de' do
+    fields = {
+      :hour      => "Stunde",
+      :minute    => "Minute",
+      :second    => "Sekunde",
+      :day       => "Tag",
+      :month     => "Monat",
+      :year      => "Jahr",
+      :week      => "Woche",
+      :weekday   => "Wochentag",
+      :dayperiod => "Tageshälfte",
+      :era       => "Epoche",
+      :zone      => "Zone"
+    }
+    assert_equal fields, gregorian[:fields]
+  end
+  
+  define_method '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
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract calendars for #{locale}" do
+  #     Cldr::Data::Calendars.new(locale)
+  #   end
+  # end
+end

data/test/data/currencies_test.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrCurrencies < Test::Unit::TestCase
+  define_method '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, :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]
+    
+    currencies = Cldr::Data::Currencies.new('de')[:currencies]
+    assert (currencies.keys - codes).empty? && (codes - currencies.keys).empty?
+    assert_equal({ :one => 'Euro', :other => 'Euro' }, currencies[:EUR])
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract currencies for #{locale}" do
+  #     assert_nothing_raised do
+  #       Cldr::Data::Currencies.new(locale)
+  #     end
+  #   end
+  # end
+end
+
+

data/test/data/delimiters_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrDataDelimiters < Test::Unit::TestCase
+  define_method 'test: delimiters :de' do
+    expected = {
+      :delimiters => {
+        :quotes => {
+          :default => {
+            :start => '„',
+            :end   => '“'
+          },
+          :alternate => {
+            :start => '‚',
+            :end   => '‘'
+          }
+        }
+      }
+    }
+    assert_equal expected, Cldr::Data::Delimiters.new('de')
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract delimiters for #{locale}" do
+  #     assert_nothing_raised do
+  #       Cldr::Data::Delimiters.new(locale)
+  #     end
+  #   end
+  # end
+end

data/test/data/languages_test.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrDataLanguages < Test::Unit::TestCase
+  define_method '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]
+    
+    languages = Cldr::Data::Languages.new('de')[:languages]
+  
+    assert (languages.keys - codes).empty? && (codes - languages.keys).empty?
+    assert_equal('Deutsch', languages[:de])
+  end
+  
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract languages for #{locale}" do
+  #     assert_nothing_raised do
+  #       Cldr::Data::Languages.new(locale)
+  #     end
+  #   end
+  # end
+end
+

data/test/data/numbers_test.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestCldrDataNumbers < Test::Unit::TestCase
+  define_method "test: number symbols :de" do
+    expected = {
+      :nan               => "NaN",
+      :decimal           => ",",
+      :plus_sign         => "+",
+      :minus_sign        => "-",
+      :group             => ".",
+      :exponential       => "E",
+      :percent_sign      => "%",
+      :list              => ";",
+      :per_mille         => "‰",
+      :native_zero_digit => "0",
+      :infinity          => "∞",
+      :pattern_digit     => "#"
+    }
+    assert_equal expected, Cldr::Data::Numbers.new('de')[:numbers][:symbols]
+  end
+
+  define_method "test: number formats :de" do
+    expected = {
+      :decimal => {
+        :patterns => {
+          :default => "#,##0.###"
+        }
+      },
+      :scientific => {
+        :patterns => {
+          :default => "#E0"
+        }
+      },
+      :percent => {
+        :patterns => {
+          :default => "#,##0 %"     # includes a non-breaking space (\302\240)
+        }
+      },
+      :currency => {
+        :patterns => {
+          :default => "#,##0.00 ¤", # includes a non-breaking space (\302\240)
+        },
+        :unit => {
+          "one"   => "{0} {1}",
+          "other" => "{0} {1}"
+        }
+      }
+    }
+    assert_equal expected, Cldr::Data::Numbers.new('de')[:numbers][:formats]
+  end
+
+  # Cldr::Data.locales.each do |locale|
+  #   define_method "test: extract number_symbols for #{locale}" do
+  #     assert_nothing_raised do
+  #       Cldr::Data::Numbers.new(locale)
+  #     end
+  #   end
+  # end
+end