ruby-cldr 0.1.0 → 0.5.0

data/lib/cldr/export/data/aliases.rb

@@ -0,0 +1,47 @@
+module Cldr
+  module Export
+    module Data
+      class Aliases < Base
+
+        # only these aliases will be exported
+        ALIAS_TAGS = %w(languageAlias territoryAlias)
+
+        def initialize
+          super(nil)
+          update(:aliases => aliases)
+        end
+
+        private
+
+        def aliases
+          ALIAS_TAGS.inject({}) do |ret, alias_tag|
+            ret[alias_tag.sub('Alias', '')] = alias_for(alias_tag)
+            ret
+          end
+        end
+
+        def alias_for(alias_tag)
+          doc.xpath("//alias/#{alias_tag}").inject({}) do |ret, alias_data|
+            if replacement_attr = alias_data.attribute('replacement')
+              replacement = replacement_attr.value
+
+              if replacement.include?(' ')
+                replacement = replacement.split(' ')
+              end
+
+              type = alias_data.attribute('type').value
+              ret[type] = replacement
+            end
+
+            ret
+          end
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/supplemental/supplementalMetadata.xml"
+        end
+
+      end
+    end
+  end
+end

data/lib/cldr/export/data/base.rb

@@ -31,6 +31,10 @@ module Cldr
             draft && draft.value == 'unconfirmed'
           end
 
+          def alt?(node)
+            !node.attribute('alt').nil?
+          end
+
           def name(node)
             node.name.underscore
           end

data/lib/cldr/export/data/characters.rb

@@ -0,0 +1,30 @@
+module Cldr
+  module Export
+    module Data
+      class Characters < Base
+        def initialize(locale)
+          super
+          update(:characters => { :exemplars => exemplars })
+        end
+
+        def exemplars
+          select('/ldml/characters/exemplarCharacters').map do |node|
+            {
+              # remove enclosing brackets
+              characters: node.content[1..-2],
+              type: type_from(node)
+            }
+          end
+        end
+
+        protected
+
+        def type_from(node)
+          if attrib = node.attribute('type')
+            attrib.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/country_codes.rb

@@ -0,0 +1,29 @@
+module Cldr
+  module Export
+    module Data
+      class CountryCodes < Base
+        def initialize
+          super(nil)
+          update(:country_codes => country_codes)
+        end
+
+        private
+
+        def country_codes 
+          doc.xpath("//codeMappings/*").each_with_object({}) do |node, hash|
+            if node.name == "territoryCodes"
+              type = node.attribute('type').to_s.to_sym
+              hash[type] = {}
+              hash[type]["numeric"] = node[:numeric] if node[:numeric]
+              hash[type]["alpha3"] = node[:alpha3] if node[:alpha3]
+            end
+          end        
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/supplemental/supplementalData.xml"
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/currencies.rb

@@ -17,17 +17,27 @@ module Cldr
 
         def currency(node)
           data = select(node, 'displayName').inject({}) do |result, node|
-            count = node.attribute('count') ? node.attribute('count').value.to_sym : :one
-            result[count] = node.content unless draft?(node)
+            unless draft?(node)
+              if node.attribute('count')
+                count = node.attribute('count').value.to_sym
+                result[count] = node.content
+              else
+                result[:one] = node.content if result[:one].nil?
+                result[:name] = node.content
+              end
+            end
+
             result
           end
 
           symbol = select(node, 'symbol')
+          narrow_symbol = symbol.select { |child_node| child_node.values.include?('narrow') }.first
           data[:symbol] = symbol.first.content if symbol.length > 0
+          data[:'narrow_symbol'] = narrow_symbol.content unless narrow_symbol.nil?
 
           data
         end
       end
     end
   end
-end
+end

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(_ = nil)
+          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/plurals/rules.rb

@@ -57,6 +57,8 @@ module Cldr
             end
 
             def parse(code)
+              code = scrub_code(code)
+
               code = code.split('@').first.to_s
               operand = /(n|i|f|t|v|w)/i
               expr = /#{operand}(?:\s+(?:mod|%)\s+([\d]+))?/i
@@ -78,6 +80,15 @@ module Cldr
                 raise "can not parse '#{code}'"
               end
             end
+
+            private
+
+            def scrub_code(code)
+              code
+                .gsub(/(n)%(\d+)/, '\1 % \2') # n%1000 -> n % 1000
+                .gsub(/(\d+)=(\d+)/, '\1 = \2') # 10=100-> 10 = 100
+                .gsub(/(n)!=(\d+)/, '\1 != \2') # n!=100 -> n != 100
+            end
           end
 
           attr_reader :locales
@@ -199,4 +210,4 @@ module Cldr
       end
     end
   end
-end
+end