ruby-cldr 0.0.1 → 0.0.2

data/lib/cldr/data/base.rb

@@ -1,66 +0,0 @@
-require 'core_ext/string/underscore'
-require 'core_ext/hash/deep_merge'
-require 'nokogiri'
-
-class Cldr
-  module Data
-    class Base < Hash
-      attr_reader :locale
-
-      def initialize(*args)
-        hash    = args.last.is_a?(Hash) ? args.pop : {}
-        @locale = args.pop.to_sym unless args.empty?
-      end
-
-      def []=(keys, value)
-        return if value.nil? || value.respond_to?(:empty?) && value.empty?
-
-        keys = keys.to_s.split('.')
-        last_key = keys.pop.to_sym
-
-        target = keys.inject(self) { |target, key| target[key.to_sym] || target.store(key.to_sym, {}) }
-        target.store(last_key, value)
-      end
-      
-      def update(hash)
-        hash.each { |key, value| self[key] = value }
-      end
-
-      protected
-
-        def plural?(node)
-          !!node.attribute('count')
-        end
-
-        def draft?(node)
-          draft = node.attribute('draft')
-          draft && draft.value == 'unconfirmed'
-        end
-
-        def name(node)
-          node.name.underscore
-        end
-
-        def count(node)
-          node.attribute('count').value
-        end
-
-        def select(*sources)
-          doc.xpath(xpath(sources))
-        end
-        
-        def xpath(sources)
-          path = sources.map { |source| source.respond_to?(:path) ? source.path : source }.join('/')
-          path =~ /^\/?\/ldml/ ? path : "//ldml/#{path}"
-        end
-
-        def doc
-          @doc ||= Nokogiri::XML(File.read(path))
-        end
-
-        def path
-          @path ||= "#{Cldr::Data.dir}/main/#{locale.to_s.gsub('-', '_')}.xml"
-        end
-    end
-  end
-end

data/lib/cldr/data/calendars.rb

@@ -1,12 +0,0 @@
-class Cldr
-  module Data
-    class Calendars < Base
-      autoload :Gregorian, 'cldr/data/calendars/gregorian'
-
-      def initialize(locale)
-        super
-        self['calendars.gregorian'] = Gregorian.new(locale)
-      end
-    end
-  end
-end

data/lib/cldr/data/calendars/gregorian.rb

@@ -1,124 +0,0 @@
-class Cldr
-  module Data
-    class Calendars
-      class Gregorian < Base
-        def initialize(locale)
-          super
-          update(
-            :months              => contexts('month'),
-            :days                => contexts('day'),
-            :eras                => contexts('era'),
-            :quarters            => contexts('quarter'),
-            :periods             => periods,
-            :fields              => fields,
-            :'formats.date'      => formats('date'),
-            :'formats.time'      => formats('time'),
-            :'formats.datetime'  => formats('dateTime')
-          )
-        end
-
-        def calendar
-          @calendar ||= select('dates/calendars/calendar[@type="gregorian"]').first
-        end
-
-        def contexts(kind)
-          select(calendar, "#{kind}s/#{kind}Context").inject({}) do |result, node|
-            context = node.attribute('type').value.to_sym
-            result[context] = widths(node, kind, context)
-            result
-          end
-        end
-
-        def widths(node, kind, context)
-          select(node, "#{kind}Width").inject({}) do |result, node|
-            width  = node.attribute('type').value.to_sym
-            result[width] = elements(node, kind, context, width)
-            result
-          end
-        end
-
-        def elements(node, kind, context, width)
-          aliased = select(node, 'alias').first
-          if aliased
-            xpath_to_key(aliased.attribute('path').value, kind, context, width)
-          else
-            select(node, kind).inject({}) do |result, node|
-              key = node.attribute('type').value
-              key = key =~ /^\d*$/ ? key.to_i : key.to_sym
-              result[key] = node.content
-              result
-            end
-          end
-        end
-        
-        def xpath_to_key(xpath, kind, context, width)
-          kind    = (xpath =~ %r(/([^\/]*)Width) && $1) || kind
-          context = (xpath =~ %r(Context\[@type='([^\/]*)'\]) && $1) || context
-          width   = (xpath =~ %r(Width\[@type='([^\/]*)'\]) && $1) || width
-          :"calendars.gregorian.#{kind}s.#{context}.#{width}"
-        end
-        
-        def xpath_width
-        end
-
-        def periods
-          am = select(calendar, "am").first
-          pm = select(calendar, "pm").first
-
-          result = {}
-          result[:am] = am.content if am
-          result[:pm] = pm.content if pm
-          result
-        end
-
-        def eras
-          base_path = calendar.path.gsub('/ldml/', '') + '/eras'
-          keys = select("#{base_path}/*").map { |node| node.name }
-
-          eras = keys.inject([]) do |result, name|
-            path = "#{base_path}/#{name}/*"
-            key  = name.gsub('era', '').gsub(/s$/, '').downcase.to_sym
-            result << extract(path, :key   => lambda { |node| node.attribute('type').value.to_i rescue 0 },
-                                    :value => lambda { |node| { key => node.content } })
-          end
-          eras.inject({}) { |result, data| result.deep_merge(data) }
-        end
-
-        def formats(type)
-          formats = select(calendar, "#{type}Formats/#{type}FormatLength").inject({}) do |result, node|
-            key = node.attribute('type').value.to_sym rescue :format
-            result[key] = pattern(node, type)
-            result
-          end
-          if default = default_format(type)
-            formats = default.merge(formats)
-          end
-          formats
-        end
-        
-        def default_format(type)
-          if node = select(calendar, "#{type}Formats/default").first
-            key = node.attribute('choice').value.to_sym
-            { :default => :"calendars.gregorian.formats.#{type.downcase}.#{key}" }
-          end
-        end
-
-        def pattern(node, type)
-          select(node, "#{type}Format/pattern").inject({}) do |result, node|
-            result[:pattern] = node.content
-            result
-          end
-        end
-
-        def fields
-          select(calendar, "fields/field").inject({}) do |result, node|
-            key  = node.attribute('type').value.to_sym
-            name = node.xpath('displayName').first
-            result[key] = name.content if name
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cldr/data/currencies.rb

@@ -1,26 +0,0 @@
-class Cldr
-  module Data
-    class Currencies < Base
-      def initialize(locale)
-        super
-        self[:currencies] = currencies
-      end
-
-      def currencies
-        select('numbers/currencies/*').inject({}) do |result, node|
-          currency = self.currency(node)
-          result[node.attribute('type').value.to_sym] = currency unless currency.empty?
-          result
-        end
-      end
-
-      def currency(node)
-        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)
-          result
-        end
-      end
-    end
-  end
-end

data/lib/cldr/data/delimiters.rb

@@ -1,21 +0,0 @@
-class Cldr
-  module Data
-    class Delimiters < Base
-      def initialize(locale)
-        super
-        self[:'delimiters.quotes.default']   = quotes('quotation')
-        self[:'delimiters.quotes.alternate'] = quotes('alternateQuotation')
-      end
-
-      def quotes(type)
-        start = select("delimiters/#{type}Start").first
-        end_  = select("delimiters/#{type}End").first
-
-        result = {}
-        result[:start] = start.content if start
-        result[:end]   = end_.content  if end_
-        result
-      end
-    end
-  end
-end

data/lib/cldr/data/languages.rb

@@ -1,17 +0,0 @@
-class Cldr
-  module Data
-    class Languages < Base
-      def initialize(locale)
-        super
-        self[:languages] = languages
-      end
-
-      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
-        end
-      end
-    end
-  end
-end

data/lib/cldr/data/numbers.rb

@@ -1,60 +0,0 @@
-class Cldr
-  module Data
-    class Numbers < Base
-      def initialize(locale)
-        super
-        self[:'numbers.symbols'] = symbols
-        self[:'numbers.formats'] = {
-          :decimal => {
-            :patterns => {
-              :default => format('decimal')
-            }
-          },
-          :scientific => {
-            :patterns => {
-              :default => format('scientific')
-            }
-          },
-          :percent => {
-            :patterns => {
-              :default => format('percent')
-            }
-          },
-          :currency => {
-            :patterns => {
-              :default => format('currency')
-            }
-          },
-        }
-        self[:'numbers.formats.currency.unit'] = unit
-      end
-      
-      def currency
-        currency = format('currency')
-        currency.update(:unit => unit) unless unit.empty?
-        currency
-      end
-
-      def symbols
-        select('numbers/symbols/*').inject({}) do |result, node|
-          result[name(node).to_sym] = node.content unless draft?(node)
-          result
-        end
-      end
-
-      def format(type)
-        select("numbers/#{type}Formats/#{type}FormatLength/#{type}Format/pattern").inject({}) do |result, node|
-          node.content unless draft?(node)
-        end
-      end
-
-      def unit
-        @unit ||= select("numbers/currencyFormats/unitPattern").inject({}) do |result, node|
-          count = node.attribute('count').value rescue 'one'
-          result[count] = node.content
-          result
-        end
-      end
-    end
-  end
-end

data/lib/cldr/data/plurals.rb

@@ -1,39 +0,0 @@
-require 'fileutils'
-
-class Cldr
-  module Data
-    class Plurals < String
-      autoload :Grammar,     'cldr/data/plurals/grammar'
-      autoload :Parser,      'cldr/data/plurals/grammar'
-      autoload :Rules,       'cldr/data/plurals/rules'
-      autoload :Rule,        'cldr/data/plurals/rules'
-      autoload :Proposition, 'cldr/data/plurals/rules'
-      autoload :Expression,  'cldr/data/plurals/rules'
-
-      class << self
-        def rules
-          @@rules ||= Rules.parse(source)
-        end
-
-        def source
-          File.read("#{Cldr::Data.dir}/supplemental/plurals.xml")
-        end
-      end
-    
-      attr_reader :locale
-
-      def initialize(locale)
-        @locale = locale
-        super(rule ? ruby : "")
-      end
-    
-      def ruby
-        "{ :#{locale} => { :i18n => {:plural => { :keys => #{rule.keys.inspect}, :rule => #{rule.to_ruby} } } } }"
-      end
-    
-      def rule
-        @rule = Plurals.rules.rule(locale)
-      end
-    end
-  end
-end

data/lib/cldr/data/plurals/grammar.rb

@@ -1,536 +0,0 @@
-# http://unicode.org/draft/reports/tr35/tr35.html#Language_Plural_Rules
-#
-# condition       = and_condition ('or' and_condition)*
-# and_condition   = relation ('and' relation)*
-# relation        = is_relation | in_relation | within_relation | 'n' <EOL>
-# is_relation     = expr 'is' ('not')? value
-# in_relation     = expr ('not')? 'in' range
-# within_relation = expr ('not')? 'within' range
-# expr            = 'n' ('mod' value)?
-# value           = digit+
-# digit           = 0|1|2|3|4|5|6|7|8|9
-# range           = value'..'value
-
-class Cldr
-  module Data
-    class Plurals
-      module Grammar
-        include Treetop::Runtime
-
-        def root
-          @root || :or_condition
-        end
-
-        module OrCondition0
-          def and_condition
-            elements[1]
-          end
-        end
-
-        module OrCondition1
-          def and_condition
-            elements[0]
-          end
-
-        end
-
-        def _nt_or_condition
-          start_index = index
-          if node_cache[:or_condition].has_key?(index)
-            cached = node_cache[:or_condition][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0, s0 = index, []
-          r1 = _nt_and_condition
-          s0 << r1
-          if r1
-            i3, s3 = index, []
-            if input.index(" or ", index) == index
-              r4 = instantiate_node(SyntaxNode,input, index...(index + 4))
-              @index += 4
-            else
-              terminal_parse_failure(" or ")
-              r4 = nil
-            end
-            s3 << r4
-            if r4
-              r5 = _nt_and_condition
-              s3 << r5
-            end
-            if s3.last
-              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-              r3.extend(OrCondition0)
-            else
-              self.index = i3
-              r3 = nil
-            end
-            if r3
-              r2 = r3
-            else
-              r2 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s0 << r2
-          end
-          if s0.last
-            r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-            r0.extend(OrCondition1)
-          else
-            self.index = i0
-            r0 = nil
-          end
-
-          node_cache[:or_condition][start_index] = r0
-
-          return r0
-        end
-
-        module AndCondition0
-          def relation
-            elements[1]
-          end
-        end
-
-        module AndCondition1
-          def relation
-            elements[0]
-          end
-
-        end
-
-        def _nt_and_condition
-          start_index = index
-          if node_cache[:and_condition].has_key?(index)
-            cached = node_cache[:and_condition][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0, s0 = index, []
-          r1 = _nt_relation
-          s0 << r1
-          if r1
-            i3, s3 = index, []
-            if input.index(" and ", index) == index
-              r4 = instantiate_node(SyntaxNode,input, index...(index + 5))
-              @index += 5
-            else
-              terminal_parse_failure(" and ")
-              r4 = nil
-            end
-            s3 << r4
-            if r4
-              r5 = _nt_relation
-              s3 << r5
-            end
-            if s3.last
-              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-              r3.extend(AndCondition0)
-            else
-              self.index = i3
-              r3 = nil
-            end
-            if r3
-              r2 = r3
-            else
-              r2 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s0 << r2
-          end
-          if s0.last
-            r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-            r0.extend(AndCondition1)
-          else
-            self.index = i0
-            r0 = nil
-          end
-
-          node_cache[:and_condition][start_index] = r0
-
-          return r0
-        end
-
-        def _nt_relation
-          start_index = index
-          if node_cache[:relation].has_key?(index)
-            cached = node_cache[:relation][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0 = index
-          r1 = _nt_is_relation
-          if r1
-            r0 = r1
-          else
-            r2 = _nt_in_relation
-            if r2
-              r0 = r2
-            else
-              r3 = _nt_within_relation
-              if r3
-                r0 = r3
-              else
-                if input.index("n", index) == index
-                  r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                  @index += 1
-                else
-                  terminal_parse_failure("n")
-                  r4 = nil
-                end
-                if r4
-                  r0 = r4
-                else
-                  self.index = i0
-                  r0 = nil
-                end
-              end
-            end
-          end
-
-          node_cache[:relation][start_index] = r0
-
-          return r0
-        end
-
-        module IsRelation0
-          def expr
-            elements[0]
-          end
-
-          def value
-            elements[3]
-          end
-        end
-
-        def _nt_is_relation
-          start_index = index
-          if node_cache[:is_relation].has_key?(index)
-            cached = node_cache[:is_relation][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0, s0 = index, []
-          r1 = _nt_expr
-          s0 << r1
-          if r1
-            if input.index(" is ", index) == index
-              r2 = instantiate_node(SyntaxNode,input, index...(index + 4))
-              @index += 4
-            else
-              terminal_parse_failure(" is ")
-              r2 = nil
-            end
-            s0 << r2
-            if r2
-              if input.index("not ", index) == index
-                r4 = instantiate_node(SyntaxNode,input, index...(index + 4))
-                @index += 4
-              else
-                terminal_parse_failure("not ")
-                r4 = nil
-              end
-              if r4
-                r3 = r4
-              else
-                r3 = instantiate_node(SyntaxNode,input, index...index)
-              end
-              s0 << r3
-              if r3
-                r5 = _nt_value
-                s0 << r5
-              end
-            end
-          end
-          if s0.last
-            r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-            r0.extend(IsRelation0)
-          else
-            self.index = i0
-            r0 = nil
-          end
-
-          node_cache[:is_relation][start_index] = r0
-
-          return r0
-        end
-
-        module InRelation0
-          def expr
-            elements[0]
-          end
-
-          def range
-            elements[3]
-          end
-        end
-
-        def _nt_in_relation
-          start_index = index
-          if node_cache[:in_relation].has_key?(index)
-            cached = node_cache[:in_relation][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0, s0 = index, []
-          r1 = _nt_expr
-          s0 << r1
-          if r1
-            if input.index(" not", index) == index
-              r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
-              @index += 4
-            else
-              terminal_parse_failure(" not")
-              r3 = nil
-            end
-            if r3
-              r2 = r3
-            else
-              r2 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s0 << r2
-            if r2
-              if input.index(" in ", index) == index
-                r4 = instantiate_node(SyntaxNode,input, index...(index + 4))
-                @index += 4
-              else
-                terminal_parse_failure(" in ")
-                r4 = nil
-              end
-              s0 << r4
-              if r4
-                r5 = _nt_range
-                s0 << r5
-              end
-            end
-          end
-          if s0.last
-            r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-            r0.extend(InRelation0)
-          else
-            self.index = i0
-            r0 = nil
-          end
-
-          node_cache[:in_relation][start_index] = r0
-
-          return r0
-        end
-
-        module WithinRelation0
-          def expr
-            elements[0]
-          end
-
-          def range
-            elements[3]
-          end
-        end
-
-        def _nt_within_relation
-          start_index = index
-          if node_cache[:within_relation].has_key?(index)
-            cached = node_cache[:within_relation][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0, s0 = index, []
-          r1 = _nt_expr
-          s0 << r1
-          if r1
-            if input.index(" not", index) == index
-              r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
-              @index += 4
-            else
-              terminal_parse_failure(" not")
-              r3 = nil
-            end
-            if r3
-              r2 = r3
-            else
-              r2 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s0 << r2
-            if r2
-              if input.index(" within ", index) == index
-                r4 = instantiate_node(SyntaxNode,input, index...(index + 8))
-                @index += 8
-              else
-                terminal_parse_failure(" within ")
-                r4 = nil
-              end
-              s0 << r4
-              if r4
-                r5 = _nt_range
-                s0 << r5
-              end
-            end
-          end
-          if s0.last
-            r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-            r0.extend(WithinRelation0)
-          else
-            self.index = i0
-            r0 = nil
-          end
-
-          node_cache[:within_relation][start_index] = r0
-
-          return r0
-        end
-
-        module Expr0
-          def value
-            elements[1]
-          end
-        end
-
-        module Expr1
-        end
-
-        def _nt_expr
-          start_index = index
-          if node_cache[:expr].has_key?(index)
-            cached = node_cache[:expr][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0, s0 = index, []
-          if input.index("n", index) == index
-            r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure("n")
-            r1 = nil
-          end
-          s0 << r1
-          if r1
-            i3, s3 = index, []
-            if input.index(" mod ", index) == index
-              r4 = instantiate_node(SyntaxNode,input, index...(index + 5))
-              @index += 5
-            else
-              terminal_parse_failure(" mod ")
-              r4 = nil
-            end
-            s3 << r4
-            if r4
-              r5 = _nt_value
-              s3 << r5
-            end
-            if s3.last
-              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-              r3.extend(Expr0)
-            else
-              self.index = i3
-              r3 = nil
-            end
-            if r3
-              r2 = r3
-            else
-              r2 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s0 << r2
-          end
-          if s0.last
-            r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-            r0.extend(Expr1)
-          else
-            self.index = i0
-            r0 = nil
-          end
-
-          node_cache[:expr][start_index] = r0
-
-          return r0
-        end
-
-        module Range0
-          def value
-            elements[0]
-          end
-
-          def value
-            elements[2]
-          end
-        end
-
-        def _nt_range
-          start_index = index
-          if node_cache[:range].has_key?(index)
-            cached = node_cache[:range][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          i0, s0 = index, []
-          r1 = _nt_value
-          s0 << r1
-          if r1
-            if input.index("..", index) == index
-              r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
-              @index += 2
-            else
-              terminal_parse_failure("..")
-              r2 = nil
-            end
-            s0 << r2
-            if r2
-              r3 = _nt_value
-              s0 << r3
-            end
-          end
-          if s0.last
-            r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-            r0.extend(Range0)
-          else
-            self.index = i0
-            r0 = nil
-          end
-
-          node_cache[:range][start_index] = r0
-
-          return r0
-        end
-
-        def _nt_value
-          start_index = index
-          if node_cache[:value].has_key?(index)
-            cached = node_cache[:value][index]
-            @index = cached.interval.end if cached
-            return cached
-          end
-
-          s0, i0 = [], index
-          loop do
-            if input.index(Regexp.new('[0-9]'), index) == index
-              r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              r1 = nil
-            end
-            if r1
-              s0 << r1
-            else
-              break
-            end
-          end
-          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-
-          node_cache[:value][start_index] = r0
-
-          return r0
-        end
-      end
-    end
-
-    class Parser < Treetop::Runtime::CompiledParser
-      include Grammar
-    end
-  end
-end