ruby-cldr 0.0.2 → 0.1.0

data/lib/cldr/export/data/layout.rb

@@ -0,0 +1,22 @@
+module Cldr
+  module Export
+    module Data
+      class Layout < Base
+        def initialize(locale)
+          super
+          update(:layout => layout)
+        end
+
+        def layout
+          result = { :orientation => { :character_order => nil } }
+
+          if node = select("layout/orientation/characterOrder/text()").first
+            result[:orientation][:character_order] = node.text
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/lists.rb

@@ -0,0 +1,28 @@
+module Cldr
+  module Export
+    module Data
+      class Lists < Base
+        def initialize(locale)
+          super
+          update(:lists => lists)
+        end
+
+        def lists
+          select('listPatterns/listPattern').inject({}) do |list_pattern_ret, list_pattern|
+            pattern_type = if attribute = list_pattern.attribute('type')
+              attribute.value.to_sym
+            else
+              :default
+            end
+
+            list_pattern_ret[pattern_type] = select(list_pattern, 'listPatternPart').inject({}) do |part_ret, part|
+              part_ret[part.attribute('type').value.to_sym] = part.content
+              part_ret
+            end
+            list_pattern_ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/metazones.rb

@@ -0,0 +1,45 @@
+require 'nokogiri'
+require 'date'
+
+module Cldr
+  module Export
+    module Data
+      class Metazones < Hash
+        def initialize
+          path = "#{Cldr::Export::Data.dir}/supplemental/metaZones.xml"
+          doc = File.open(path) { |file| Nokogiri::XML(file) }
+          self[:timezones] = doc.xpath('//metaZones/metazoneInfo/timezone').inject({}) do |result, node|
+            timezone = node.attr('type').to_sym
+            result[timezone] = metazone(node.xpath('usesMetazone'))
+            result[timezone].sort_by! { |zone| [zone['from'] ? zone['from'] : DateTime.new, zone['to'] ? zone['to'] : DateTime.now] }
+            result
+          end
+          self[:primaryzones] = doc.xpath('//primaryZones/primaryZone').inject({}) do |result, node|
+            territory = node.attr('iso3166').to_sym
+            result[territory] = node.content
+            result
+          end
+        end
+
+        protected
+
+        def metazone(nodes)
+          nodes.inject([]) do |result, node|
+            mzone = node.attr('mzone')
+            from = node.attr('from')
+            to = node.attr('to')
+            data = { 'metazone' => mzone }
+            data['from'] = parse_date(from) if from
+            data['to'] = parse_date(to) if to
+            result << data
+            result
+          end
+        end
+
+        def parse_date(date)
+          DateTime.strptime(date + ' UTC', '%F %R %Z')
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/data/numbering_systems.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Cldr
+  module Export
+    module Data
+      class NumberingSystems < Base
+
+        def initialize(*args)
+          super(nil)
+          update(:numbering_systems => numbering_systems)
+        end
+
+        def numbering_systems
+          doc.xpath("supplementalData/numberingSystems/numberingSystem").inject({}) do |ret, numbering|
+            system_name = numbering.attribute("id").value
+            type = numbering.attribute("type").value
+
+            param = case type
+              when "numeric"
+                "digits"
+              when "algorithmic"
+                "rules"
+            end
+
+            ret[system_name] = {
+              :type => type,
+              param => numbering.attribute(param).value
+            }
+
+            ret
+          end
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/supplemental/numberingSystems.xml"
+        end
+
+      end
+    end
+  end
+end

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

@@ -9,15 +9,19 @@ module Cldr
               :symbols => symbols,
               :formats => {
                 :decimal => {
+                  :number_system => number_system('decimal'),
                   :patterns => format('decimal')
                 },
                 :scientific => {
+                  :number_system => number_system('scientific'),
                   :patterns => format('scientific')
                 },
                 :percent => {
+                  :number_system => number_system('percent'),
                   :patterns => format('percent')
                 },
                 :currency => {
+                  :number_system => number_system('currency'),
                   :patterns => format('currency'),
                   :unit => unit
                 }
@@ -54,6 +58,11 @@ module Cldr
           result
         end
 
+        def number_system(type)
+          node = select("numbers/#{type}Formats").first
+          node.attribute('numberSystem').value rescue "latn"
+        end
+
         def unit
           @unit ||= select("numbers/currencyFormats/unitPattern").inject({}) do |result, node|
             count = node.attribute('count').value rescue 'one'

data/lib/cldr/export/data/plurals.rb

@@ -3,7 +3,7 @@ require 'fileutils'
 module Cldr
   module Export
     module Data
-      class Plurals < String
+      class Plurals < Hash
         autoload :Grammar,     'cldr/export/data/plurals/grammar'
         autoload :Parser,      'cldr/export/data/plurals/grammar'
         autoload :Rules,       'cldr/export/data/plurals/rules'
@@ -20,18 +20,19 @@ module Cldr
             File.read("#{Cldr::Export::Data.dir}/supplemental/plurals.xml")
           end
         end
-    
+
         attr_reader :locale
 
         def initialize(locale)
           @locale = locale
-          super(rule ? ruby : "")
+          self.merge!(rule ? to_hash : {})
         end
-    
-        def ruby
-          "{ :#{locale} => { :i18n => {:plural => { :keys => #{rule.keys.inspect}, :rule => #{rule.to_ruby} } } } }"
+
+        def to_hash
+          rule_rb = rule ? rule.to_ruby : nil
+          { :keys => (rule || {}).keys, :rule => rule_rb }
         end
-    
+
         def rule
           @rule = Plurals.rules.rule(locale)
         end

data/lib/cldr/export/data/plurals/rules.rb

@@ -17,15 +17,15 @@ module Cldr
               rules
             end
           end
-      
+
           def locales
             @locales ||= map { |rule| rule.locales }.flatten.map(&:to_s).sort.map(&:to_sym)
           end
-      
+
           def rule(locale)
             detect { |rule| rule.locales.include?(locale.to_sym) }
           end
-      
+
           def to_ruby(options = {})
             namespaces = options[:namespaces] || [:i18n]
             code = locales.map do |locale|
@@ -38,25 +38,44 @@ module Cldr
             "{\n" + code + "\n}"
           end
         end
-    
+
         class Rule < Array
           class << self
+
+            def parse_list(str)
+              values = []
+              ranges = []
+              str.split(',').each do |value|
+                parts = value.split('..')
+                if parts.count == 1
+                  values << value.to_i
+                else
+                  ranges << (parts.first.to_i..parts.last.to_i)
+                end
+              end
+              [values, ranges]
+            end
+
             def parse(code)
+              code = code.split('@').first.to_s
+              operand = /(n|i|f|t|v|w)/i
+              expr = /#{operand}(?:\s+(?:mod|%)\s+([\d]+))?/i
+              range = /(?:\d+\.\.\d+|\d+)/i
+              range_list = /(#{range}(?:\s*,\s*#{range})*)/i
               case code
-              when /and/
-                code.split(/and/).inject(Proposition.new('&&')) { |rule, code| rule << parse(code) }
-              when /or/
-                code.split(/or/).inject(Proposition.new('||')) { |rule, code| rule << parse(code) }
-              when /n( mod ([\d]+))? is (not )?([\d]+)/
-                Expression.new(:is, $2, !!$3, $4)
-              when /n( mod ([\d]+))?( not)? in ([\d]+\.\.[\d]+)/
-                Expression.new(:in, $2, !!$3, eval($4).to_a.inspect)
-              when /n within ([\d]+)\.\.([\d]+)/
-                Expression.new(:within, nil, nil, [$1, $2])
-              when /n/
+              when /or/i
+                code.split(/or/i).inject(Proposition.new('||')) { |rule, code| rule << parse(code) }
+              when /and/i
+                code.split(/and/i).inject(Proposition.new('&&')) { |rule, code| rule << parse(code) }
+              when /^\s*#{expr}\s+(?:is(\s+not)?|(not\s+)?in|(!)?=)\s+#{range_list}\s*$/i
+                list = parse_list($6)
+                Expression.new((list.first.count == 1 && list.last.count == 0) ? :is : :in, $2, !($3.nil? && $4.nil? && $5.nil?), (list.first.count == 1 && list.last.count == 0) ? list.first.first : list, $1)
+              when /^\s*#{expr}\s+(not\s+)?within\s+#{range_list}\s*$/i
+                Expression.new(:within, $2, !($3==nil), parse_list($4).last.first, $1)
+              when /^\s*$/
                 Expression.new
               else
-                raise "can not parse #{code}"
+                raise "can not parse '#{code}'"
               end
             end
           end
@@ -66,15 +85,19 @@ module Cldr
           def initialize(locales)
             @locales = locales.map { |locale| locale.gsub('_', '-').to_sym }
           end
-      
+
           def keys
-            inject([]) { |keys, (key, code)| keys << key.to_sym } << :other
+            inject([]) { |keys, (key, code)| keys << key.to_sym }
           end
-      
+
           def to_ruby
-            @condition ||= 'lambda { |n| ' + reverse.inject(':other') do |result, (key, code)|
+            @condition ||= 'lambda { |n| n = n.respond_to?(:abs) ? n.abs : ((m = n.to_s)[0] == "-" ? m[1,m.length] : m); ' + reverse.inject(':other') do |result, (key, code)|
               code = self.class.parse(code).to_ruby
-              "#{code} ? :#{key} : #{result}"
+              if code
+                "#{code} ? :#{key} : #{result}"
+              else
+                ':' << key.to_s
+              end
             end + ' }'
           end
         end
@@ -85,30 +108,90 @@ module Cldr
           end
 
           def to_ruby
-            @ruby ||= map { |expr| expr.to_ruby }.join(" #{@type} ")
+            @ruby ||= '(' << map { |expr| expr.to_ruby }.join(" #{@type} ") << ')'
           end
         end
 
         class Expression
-          attr_reader :operator, :operand, :mod, :negate
+          attr_reader :operator, :operand, :mod, :negate, :type
 
-          def initialize(operator = nil, mod = nil, negate = nil, operand = nil)
-            @operator, @mod, @negate, @operand = operator, mod, negate, operand
+          def initialize(operator = nil, mod = nil, negate = nil, operand = nil, type = nil)
+            @operator, @mod, @negate, @operand, @type = operator, mod, negate, operand, type
           end
 
+          # Symbol  Value
+          # n       absolute value of the source number (integer and decimals).
+          # i       integer digits of n.
+          # v       number of visible fraction digits in n, with trailing zeros.
+          # w       number of visible fraction digits in n, without trailing zeros.
+          # f       visible fractional digits in n, with trailing zeros.
+          # t       visible fractional digits in n, without trailing zeros.
+          #
+          # http://www.unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules
           def to_ruby
             @ruby ||= begin
-              op = 'n'
-              op << " % #{@mod}" if mod
+              return nil unless @operator
+              enclose = false
+              fraction = false
+              case @type
+              when 'i'
+                op = 'n.to_i'
+              when 'f'
+                op = '(f = n.to_s.split(".")[1]) ? f.to_i : 0'
+                enclose = true
+              when 't'
+                op = '(t = n.to_s.split(".")[1]) ? t.gsub(/0+$/, "").to_i : 0'
+                enclose = true
+              when 'v'
+                op = '(v = n.to_s.split(".")[1]) ? v.length : 0'
+                enclose = true
+              when 'w'
+                op = '(w = n.to_s.split(".")[1]) ? w.gsub(/0+$/, "").length : 0'
+                enclose = true
+              else
+                fraction = true
+                op = 'n.to_f'
+              end
+              if @mod
+                op = '(' << op << ')' if enclose
+                op << ' % ' << @mod.to_s
+                enclose = false
+              end
               case @operator
               when :is
-                op + (@negate ? ' != ' : ' == ') + @operand
+                op = '(' << op << ')' if enclose
+                op << (@negate ? ' != ' : ' == ') << @operand.to_s
               when :in
-                (@negate ? '!' : '') + "#{@operand}.include?(#{op})"
+                values = @operand.first
+                ranges = @operand.last
+                prepend = (@negate ? '!' : '')
+                str = ''
+                bop = op
+                bop = '(' << bop << ')' if enclose || @mod
+                if values.count == 1
+                  str = bop + (@negate ? ' != ' : ' == ') << values.first.to_s
+                elsif values.count > 1
+                  str = prepend + "#{values.inspect}.include?(#{op})"
+                end
+                enclose = ranges.count > 1 || (values.count > 0 && ranges.count > 0)
+                if ranges.count > 0
+                  str << ' || ' if values.count > 0
+                  str << "((#{bop} % 1).zero? && " if fraction
+                  str << '(' if ranges.count > 1
+                  str << prepend + "(#{ranges.shift.inspect}).include?(#{op})"
+                  ranges.each do |range|
+                    str << ' || ' << prepend + "(#{range.inspect}).include?(#{op})"
+                  end
+                  str << ')' if ranges.count > 0
+                  str << ')' if fraction
+                end
+                str = '(' << str << ')' if enclose
+                str
               when :within
-                "#{op}.between?(#{@operand.first}, #{@operand.last})" 
+                op = '(' << op << ')' if enclose || @mod
+                (@negate ? '!' : '') + "#{op}.between?(#{@operand.first}, #{@operand.last})"
               else
-                op
+                raise "unknown operator '#{@operator}'"
               end
             end
           end

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

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+module Cldr
+  module Export
+    module Data
+      class Rbnf < Base
+
+        def initialize(*args)
+          super
+          update(:rbnf => { :grouping => rule_groups })
+        end
+
+        def rule_groups
+          if File.exist?(path)
+            select("rbnf/rulesetGrouping").map do |grouping_node|
+              {
+                :type => grouping_node.attribute("type").value,
+                :ruleset => (grouping_node / "ruleset").map do |ruleset_node|
+                  rule_set(ruleset_node)
+                end
+              }
+            end
+          else
+            {}
+          end
+        end
+
+        def rule_set(ruleset_node)
+          attrs = {
+            :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
+              else
+                nil
+              end
+              
+              attrs = {
+                :value => rule_node.attribute("value").value,
+                :rule => fix_rule(rule_node.text)
+              }
+
+              attrs[:radix] = radix if radix
+              attrs
+            end
+          }
+
+          access = ruleset_node.attribute("access")
+          attrs[:access] = access.value if access
+          attrs
+        end
+
+        def fix_rule(rule)
+          rule.gsub(/\A'/, '').gsub("←", '<').gsub("→", '>')
+        end
+
+        def path
+          @path ||= "#{Cldr::Export::Data.dir}/rbnf/#{locale.to_s.gsub('-', '_')}.xml"
+        end
+
+      end
+    end
+  end
+end