ruby-cldr 0.1.1 → 0.2.0

data/lib/cldr/export/data/fields.rb

@@ -0,0 +1,60 @@
+module Cldr
+  module Export
+    module Data
+      class Fields < Base
+        def initialize(locale)
+          super
+          update(:fields => fields)
+        end
+
+        private
+
+        def fields
+          select('dates/fields/field').each_with_object({}) do |field_node, ret|
+            type = field_node.attribute('type').value
+            ret[type] = field(field_node)
+          end
+        end
+
+        def field(field_node)
+          result = {}
+
+          unless (display_name = (field_node / 'displayName').text).empty?
+            result[:display_name] = display_name
+          end
+
+          unless (forms = relative_forms(field_node)).empty?
+            result[:relative] = forms
+          end
+
+          unless (forms = relative_time_forms(field_node)).empty?
+            result[:relative_time] = forms
+          end
+
+          result
+        end
+
+        def relative_forms(field_node)
+          (field_node / 'relative').each_with_object({}) do |relative_node, ret|
+            type = relative_node.attribute('type').value.to_i
+            ret[type] = relative_node.text
+          end
+        end
+
+        def relative_time_forms(field_node)
+          (field_node / 'relativeTime').each_with_object({}) do |relative_time_node, ret|
+            type = relative_time_node.attribute('type').value
+            ret[type] = relative_time_patterns(relative_time_node)
+          end
+        end
+
+        def relative_time_patterns(relative_time_node)
+          (relative_time_node / 'relativeTimePattern').each_with_object({}) do |relative_time_pattern_node, ret|
+            count = relative_time_pattern_node.attribute('count').value
+            ret[count] = relative_time_pattern_node.text
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/languages.rb

@@ -9,7 +9,7 @@ module Cldr
 
         def languages
           @languages ||= select('localeDisplayNames/languages/language').inject({}) do |result, node|
-            result[node.attribute('type').value.gsub('_', '-').to_sym] = node.content unless draft?(node)
+            result[node.attribute('type').value.gsub('_', '-').to_sym] = node.content unless draft?(node) or alt?(node)
             result
           end
         end

data/lib/cldr/export/data/likely_subtags.rb

@@ -0,0 +1,29 @@
+module Cldr
+  module Export
+    module Data
+      class LikelySubtags < Base
+
+        def initialize
+          super(nil)
+          update(:subtags => subtags)
+        end
+
+        private
+
+        def subtags
+          doc.xpath('//likelySubtag').inject({}) do |ret, subtag|
+            from = subtag.attribute('from').value
+            to = subtag.attribute('to').value
+            ret[from] = to
+            ret
+          end
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/supplemental/likelySubtags.xml"
+        end
+
+      end
+    end
+  end
+end

data/lib/cldr/export/data/numbers.rb

@@ -44,13 +44,48 @@ module Cldr
         end
 
         def format(type)
-          result = select("numbers/#{type}Formats/#{type}FormatLength/#{type}Format").inject({}) do |format_result, format_node|
-            format_key = format_node.parent.attribute('type')
-            format_result[format_key ? format_key.value : :default] = select(format_node, "pattern").inject({}) do |pattern_result, pattern_node|
-              pattern_key = pattern_node.attribute('type')
-              pattern_result[pattern_key ? pattern_key.value : :default] = pattern_node.content unless draft?(pattern_node)
-              pattern_result
+          result = select("numbers/#{type}Formats/#{type}FormatLength").inject({}) do |format_result, format_length_node|
+            format_nodes = select(format_length_node, "#{type}Format")
+
+            format_key = format_length_node.attribute('type')
+            format_key = format_key ? format_key.value : :default
+
+            if format_nodes.size > 0
+              format_nodes.each do |format_node|
+                format_result[format_key] ||= select(format_node, "pattern").inject({}) do |pattern_result, pattern_node|
+                  pattern_key_node = pattern_node.attribute('type')
+
+                  pattern_count_node = pattern_node.attribute('count')
+
+                  unless draft?(pattern_node)
+                    pattern_key = pattern_key_node ? pattern_key_node.value : :default
+
+                    if pattern_count_node
+                      pattern_count = pattern_count_node.value
+
+                      if pattern_result[pattern_key].nil?
+                        pattern_result[pattern_key] ||= {}
+                      elsif !pattern_result[pattern_key].is_a?(Hash)
+                        raise "can't parse patterns with and without 'count' attribute in the same section"
+                      end
+
+                      pattern_result[pattern_key][pattern_count] = pattern_node.content
+                    else
+                      pattern_result[pattern_key] = pattern_node.content
+                    end
+                  end
+
+                  pattern_result
+                end
+              end
+            else
+              aliased = select(format_length_node, 'alias').first
+
+              if aliased
+                format_result[format_key] = xpath_to_redirect(aliased.attribute('path').value)
+              end
             end
+
             format_result
           end
 
@@ -58,6 +93,13 @@ module Cldr
           result
         end
 
+        def xpath_to_redirect(xpath)
+          length = xpath[/(\w+)FormatLength/, 1]
+          type   = xpath[/@type='(\w+)'/, 1]
+
+          :"numbers.formats.#{length}.patterns.#{type}"
+        end
+
         def number_system(type)
           node = select("numbers/#{type}Formats").first
           node.attribute('numberSystem').value rescue "latn"

data/lib/cldr/export/data/parent_locales.rb

@@ -0,0 +1,23 @@
+require 'nokogiri'
+
+module Cldr
+  module Export
+    module Data
+      class ParentLocales < Hash
+        def initialize(_)
+          path = File.join(Cldr::Export::Data.dir, 'supplemental', 'supplementalData.xml')
+          doc = File.open(path) { |file| Nokogiri::XML(file) }
+
+          doc.xpath('//parentLocales/parentLocale').each do |node|
+            parent = node.attr('parent')
+            locales = node.attr('locales').split(' ')
+
+            locales.each do |locale|
+              self[locale] = parent
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/plural_rules.rb

@@ -0,0 +1,70 @@
+require 'nokogiri'
+
+module Cldr
+  module Export
+    module Data
+      class PluralRules < Hash
+        attr_reader :locale
+
+        def initialize(locale)
+          find_rules(locale).each_pair do |rule_type, rule_data|
+            self[rule_type.to_sym] = rule_data.inject({}) do |ret, rule|
+              ret[rule.attributes['count'].text] = rule.text
+              ret
+            end
+          end
+        end
+
+        private
+
+        def sources
+          @sources ||= ['plurals', 'ordinals'].inject({}) do |ret, source_name|
+            ret[source_name] = ::Nokogiri::XML(
+              File.read("#{Cldr::Export::Data.dir}/supplemental/#{source_name}.xml")
+            )
+            ret
+          end
+        end
+
+        def find_rules(locale)
+          locale = locale.to_s
+
+          sources.inject({}) do |ret, (file, source)|
+            # try to find exact match, then fall back
+            node = find_rules_for_exact_locale(locale, source) ||
+              find_rules_for_exact_locale(base_locale(locale), source) ||
+              find_rules_for_base_locale(locale, source) ||
+              find_rules_for_base_locale(base_locale(locale), source)
+
+            if node
+              name = (source / 'plurals').first.attributes['type'].value
+              ret[name] = node / 'pluralRule'
+            end
+
+            ret
+          end
+        end
+
+        def find_rules_for_exact_locale(locale, source)
+          (source / 'plurals/pluralRules').find do |node|
+            node.attributes['locales'].text
+              .split(' ').map(&:downcase)
+              .include?(locale.downcase)
+          end
+        end
+
+        def find_rules_for_base_locale(locale, source)
+          (source / 'plurals/pluralRules').find do |node|
+            node.attributes['locales'].text
+              .split(' ').map { |l| base_locale(l) }
+              .include?(locale.downcase)
+          end
+        end
+
+        def base_locale(locale)
+          locale.split(/[_-]/).first
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/rbnf.rb

@@ -30,13 +30,13 @@ module Cldr
             :type => ruleset_node.attribute("type").value,
             :rules => (ruleset_node / "rbnfrule").map do |rule_node|
               radix = if radix_attr = rule_node.attribute("radix")
-                radix_attr.value
+                cast_value(radix_attr.value)
               else
                 nil
               end
-              
+
               attrs = {
-                :value => rule_node.attribute("value").value,
+                :value => cast_value(rule_node.attribute("value").value),
                 :rule => fix_rule(rule_node.text)
               }
 
@@ -50,6 +50,14 @@ module Cldr
           attrs
         end
 
+        def cast_value(val)
+          if val =~ /\A[\d]+\z/
+            val.to_i
+          else
+            val
+          end
+        end
+
         def fix_rule(rule)
           rule.gsub(/\A'/, '').gsub("←", '<').gsub("→", '>')
         end
@@ -61,4 +69,4 @@ module Cldr
       end
     end
   end
-end
+end

data/lib/cldr/export/data/region_currencies.rb

@@ -0,0 +1,45 @@
+module Cldr
+  module Export
+    module Data
+      class RegionCurrencies < Base
+
+        def initialize
+          super(nil)
+          update(:region_currencies => currencies)
+        end
+
+        private
+
+        def currencies
+          doc.xpath('//currencyData/region').inject({}) do |ret, region|
+            name = region.attribute('iso3166').value
+            ret[name] = currency(region)
+            ret
+          end
+        end
+
+        def currency(node)
+          (node / 'currency').map do |currency|
+            currency_code = currency.attribute('iso4217').value
+            result = { currency: currency_code }
+
+            if from_node = currency.attribute('from')
+              result[:from] = from_node.value
+            end
+
+            if to_node = currency.attribute('to')
+              result[:to] = to_node.value
+            end
+
+            result
+          end
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/supplemental/supplementalData.xml"
+        end
+
+      end
+    end
+  end
+end

data/lib/cldr/export/data/segments_root.rb

@@ -26,7 +26,7 @@ module Cldr
         def variables(node)
           (node / "variables" / "variable").map do |variable|
             {
-              :id => variable.attribute("id").value,
+              :id => cast_value(variable.attribute("id").value),
               :value => variable.text
             }
           end
@@ -35,7 +35,7 @@ module Cldr
         def rules(node)
           (node / "segmentRules" / "rule").map do |rule|
             {
-              :id => rule.attribute("id").value,
+              :id => cast_value(rule.attribute("id").value),
               :value => rule.text
             }
           end
@@ -45,7 +45,17 @@ module Cldr
           @path ||= "#{Cldr::Export::Data.dir}/segments/root.xml"
         end
 
+        def cast_value(value)
+          if value =~ /\A[\d]+\z/
+            value.to_i
+          elsif value =~ /\A[\d.]+\z/
+            value.to_f
+          else
+            value
+          end
+        end
+
       end
     end
   end
-end
+end

data/lib/cldr/export/data/territories.rb

@@ -9,7 +9,7 @@ module Cldr
 
         def territories
           @territories ||= select('localeDisplayNames/territories/territory').inject({}) do |result, node|
-            result[node.attribute('type').value.to_sym] = node.content unless draft?(node)
+            result[node.attribute('type').value.to_sym] = node.content unless draft?(node) or alt?(node)
             result
           end
         end

data/lib/cldr/export/data/territories_containment.rb

@@ -0,0 +1,30 @@
+module Cldr
+  module Export
+    module Data
+      class TerritoriesContainment < Base
+        def initialize(*)
+          super(nil)
+          update(:territories => territories)
+        end
+
+        def territories
+          @territories ||= doc.xpath('supplementalData/territoryContainment/group').inject(
+            Hash.new { |h, k| h[k] = { :contains => [] } }
+          ) do |memo, territory|
+            territory_id = territory.attribute('type').value
+            children = territory.attribute('contains').value.split(' ')
+
+            memo[territory_id][:contains].concat(children)
+            memo[territory_id][:contains].sort!
+
+            memo
+          end
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/supplemental/supplementalData.xml"
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,23 @@ module Cldr
       class Timezones < Base
         def initialize(locale)
           super
-          update(:timezones => timezones, :metazones => metazones)
+
+          update(
+            :formats => formats,
+            :timezones => timezones,
+            :metazones => metazones
+          )
+        end
+
+        def formats
+          @formats ||= select('dates/timeZoneNames/*').inject({}) do |result, format|
+            if format.name.end_with?('Format')
+              underscored_name = format.name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+              result[underscored_name] = format.text
+            end
+
+            result
+          end
         end
 
         def timezones
@@ -47,4 +63,4 @@ module Cldr
       end
     end
   end
-end
+end