ruby-cldr 0.0.1

data/lib/cldr/data/timezones.rb

@@ -0,0 +1,25 @@
+# I probably don't really get timezones.
+
+class Cldr
+  module Data
+    class Timezones < Base
+      def initialize(locale)
+        super
+        self[:timezones] = timezones
+      end
+
+      def timezones
+        @timezones ||= select('dates/timeZoneNames/zone').inject({}) do |result, zone|
+          type = zone.attribute('type').value.to_sym
+          city = select(zone, 'exemplarCity').first
+          result[type] = {}
+          # see en.xml, Europe/London, does not have an exemplarCity element
+          # instead it has long and short daylight names which otherwise only
+          # have metazones. (??)
+          result[type][:city] = city.content if city
+          result
+        end
+      end
+    end
+  end
+end

data/lib/cldr/data/units.rb

@@ -0,0 +1,25 @@
+class Cldr
+  module Data
+    class Units < Base
+      def initialize(locale)
+        super
+        self[:units] = units
+      end
+
+      def units
+        select('units/unit').inject({}) do |result, node|
+          result[node.attribute('type').value.to_sym] = unit(node)
+          result
+        end
+      end
+
+      def unit(node)
+        node.xpath('unitPattern').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.rb

@@ -0,0 +1,34 @@
+require 'core_ext/string/camelize'
+
+class Cldr
+  module Data
+    autoload :Base,          'cldr/data/base'
+    autoload :Calendars,     'cldr/data/calendars'
+    autoload :Currencies,    'cldr/data/currencies'
+    autoload :Delimiters,    'cldr/data/delimiters'
+    autoload :Languages,     'cldr/data/languages'
+    autoload :Numbers,       'cldr/data/numbers'
+    autoload :Plurals,       'cldr/data/plurals'
+    autoload :Territories,   'cldr/data/territories'
+    autoload :Timezones,     'cldr/data/timezones'
+    autoload :Units,         'cldr/data/units'
+
+    class << self
+      def dir
+        @dir ||= File.expand_path('./vendor/cldr/common')
+      end
+      
+      def dir=(dir)
+        @dir = dir
+      end
+
+      def locales
+        Dir["#{dir}/main/*.xml"].map { |path| path =~ /([\w_-]+)\.xml/ && $1 }
+      end
+
+      def components
+        self.constants.sort - [:Base, :Export]
+      end
+    end
+  end
+end

data/lib/cldr/download.rb

@@ -0,0 +1,20 @@
+require 'fileutils'
+require 'net/http'
+require 'uri'
+require 'tempfile'
+
+class Cldr
+  class << self
+    def download(source = nil, target = nil)
+      source ||= 'http://unicode.org/Public/cldr/1.7.2/core.zip'
+      target ||= File.expand_path('./vendor/cldr')
+
+      source = URI.parse(source)
+      tempfile = Tempfile.new('cldr-core')
+
+      system("curl #{source} -o #{tempfile.path}")
+      FileUtils.mkdir_p(target)
+      system("unzip #{tempfile.path} -d #{target}")
+    end
+  end
+end

data/lib/cldr/export/ruby.rb

@@ -0,0 +1,16 @@
+class Cldr
+  module Export
+    class Ruby
+      def export(locale, component, options = {})
+        data = Export.data(component, locale, options)
+        data = data.to_ruby if data.respond_to?(:to_ruby)
+        unless data.empty?
+          path = Export.path(locale, component, 'rb')
+          Export.write(path, data) 
+          yield(component, locale, path) if block_given?
+          data
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/yaml.rb

@@ -0,0 +1,39 @@
+require 'ya2yaml'
+
+class Cldr
+  module Export
+    class Yaml < Ya2YAML
+      def initialize
+        super(:syck_compatible => true)
+      end
+
+      def export(locale, component, options = {})
+        data = Export.data(component, locale, options)
+        unless data.empty?
+          data = { locale.to_s.gsub('_', '-') => data }.deep_stringify_keys
+          path = Export.path(locale, component, 'yml')
+          Export.write(path, yaml(data))
+          yield(component, locale, path) if block_given?
+          data
+        end
+      end
+
+    	def yaml(data)
+    		emit(data, 1)[1..-1]
+    	end
+
+    	def emit(object, level = 1)
+    		result = object.is_a?(Symbol) ? object.inspect : super
+    		result.gsub(/(\s{1})(no):/i) { %(#{$1}"#{$2}":) } # FIXME fucking spaghetti code
+    	end
+
+    	def is_one_plain_line?(str)
+    		# removed REX_BOOL, REX_INT
+    		str !~ /^([\-\?:,\[\]\{\}\#&\*!\|>'"%@`\s]|---|\.\.\.)/    &&
+    		str !~ /[:\#\s\[\]\{\},]/                                  &&
+    		str !~ /#{REX_ANY_LB}/                                     &&
+    		str !~ /^(#{REX_FLOAT}|#{REX_MERGE}|#{REX_NULL}|#{REX_TIMESTAMP}|#{REX_VALUE})$/x
+    	end
+    end
+  end
+end

data/lib/cldr/export.rb

@@ -0,0 +1,69 @@
+require 'i18n'
+require 'i18n/locale/fallbacks'
+require 'core_ext/string/camelize'
+require 'core_ext/string/underscore'
+require 'core_ext/hash/deep_stringify_keys'
+
+class Cldr
+  module Export
+    autoload :Ruby, 'cldr/export/ruby'
+    autoload :Yaml, 'cldr/export/yaml'
+
+    class << self
+      def base_path
+        @@base_path ||= File.expand_path('./data')
+      end
+
+      def base_path=(base_path)
+        @@base_path = base_path
+      end
+
+      def export(options = {}, &block)
+        locales        = options[:locales]    || Data.locales
+        components     = options[:components] || Data.components
+        self.base_path = options[:target] if options[:target]
+
+        locales.each do |locale|
+          components.each do |component|
+            exporter(component, options[:format]).export(locale, component, options, &block)
+          end
+        end
+      end
+
+      def exporter(component, format)
+        name = format ? format : component.to_s == 'Plurals' ? 'ruby' : 'yaml'
+        const_get(name.to_s.camelize).new
+      end
+
+      def data(component, locale, options = {})
+        if component.to_s == 'Plurals'
+          Data.const_get(component.to_s.camelize).new(locale)
+        else
+          data = locales(locale, options).inject({}) do |result, locale|
+            data = Data.const_get(component.to_s.camelize).new(locale)
+            data ? data.deep_merge(result) : result
+          end
+          # data = resolve_links if options[:merge] TODO!!
+          data
+        end
+      end
+
+      def locales(locale, options)
+        locale = locale.to_s.gsub('_', '-')
+        locales = options[:merge] ? I18n::Locale::Fallbacks.new[locale.to_sym] : [locale.to_sym] 
+        locales << :root
+        locales
+      end
+
+      def write(path, data)
+        FileUtils.rm(path) if File.exists?(path)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'w+') { |f| f.write(data) }
+      end
+
+      def path(locale, component, extension)
+        "#{Export.base_path}/#{locale.to_s.gsub('_', '-')}/#{component.to_s.underscore}.#{extension}"
+      end
+    end
+  end
+end

data/lib/cldr/format/currency.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+class Cldr
+  module Format
+    class Currency < Decimal
+      def apply(number, options = {})
+        super.gsub('¤', options[:currency] || '$')
+      end
+    end
+  end
+end

data/lib/cldr/format/date.rb

@@ -0,0 +1,144 @@
+class Cldr
+  module Format
+    class Date < Datetime::Base
+      PATTERN = /G{1,5}|y+|Y+|Q{1,4}|q{1,5}|M{1,5}|L{1,5}|d{1,2}|F{1}|E{1,5}|e{1,5}|c{1,5}/
+      METHODS = { # ignoring u, l, g, j, A
+        'G' => :era,
+        'y' => :year,
+        'Y' => :year_of_week_of_year,
+        'Q' => :quarter,
+        'q' => :quarter_stand_alone,
+        'M' => :month,
+        'L' => :month_stand_alone,
+        'w' => :week_of_year,
+        'W' => :week_of_month,
+        'd' => :day,
+        'D' => :day_of_month,
+        'F' => :day_of_week_in_month,
+        'E' => :weekday,
+        'e' => :weekday_local,
+        'c' => :weekday_local_stand_alone,
+      }
+
+      def era(date, pattern, length)
+        raise 'not implemented'
+      end
+
+      def year(date, pattern, length)
+        year = date.year.to_s
+        year = year.length == 1 ? year : year[-2, 2] if length == 2
+        year = year.rjust(length, '0') if length > 1
+        year
+      end
+
+      def year_of_week_of_year(date, pattern, length)
+        raise 'not implemented'
+      end
+
+      def day_of_week_in_month(date, pattern, length) # e.g. 2nd Wed in July
+        raise 'not implemented'
+      end
+
+      def quarter(date, pattern, length)
+        quarter = (date.month.to_i - 1) / 3 + 1
+        case length
+        when 1
+          quarter.to_s
+        when 2
+          quarter.to_s.rjust(length, '0')
+        when 3
+          calendar[:quarters][:format][:abbreviated][quarter]
+        when 4
+          calendar[:quarters][:format][:wide][quarter]
+        end
+      end
+
+      def quarter_stand_alone(date, pattern, length)
+        quarter = (date.month.to_i - 1) / 3 + 1
+        case length
+        when 1
+          quarter.to_s
+        when 2
+          quarter.to_s.rjust(length, '0')
+        when 3
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          # calendar[:quarters][:'stand-alone'][:abbreviated][key]
+        when 4
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          # calendar[:quarters][:'stand-alone'][:wide][key]
+        when 5
+          calendar[:quarters][:'stand-alone'][:narrow][quarter]
+        end
+      end
+
+      def month(date, pattern, length)
+        case length
+        when 1
+          date.month.to_s
+        when 2
+          date.month.to_s.rjust(length, '0')
+        when 3
+          calendar[:months][:format][:abbreviated][date.month]
+        when 4
+          calendar[:months][:format][:wide][date.month]
+        when 5
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          calendar[:months][:format][:narrow][date.month]
+        else
+          # raise unknown date format
+        end
+      end
+
+      def month_stand_alone(date, pattern, length)
+        case length
+        when 1
+          date.month.to_s
+        when 2
+          date.month.to_s.rjust(length, '0')
+        when 3
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          calendar[:months][:'stand-alone'][:abbreviated][date.month]
+        when 4
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          calendar[:months][:'stand-alone'][:wide][date.month]
+        when 5
+          calendar[:months][:'stand-alone'][:narrow][date.month]
+        else
+          # raise unknown date format
+        end
+      end
+
+      def day(date, pattern, length)
+        case length
+        when 1
+          date.day.to_s
+        when 2
+          date.day.to_s.rjust(length, '0')
+        end
+      end
+
+      WEEKDAY_KEYS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
+
+      def weekday(date, pattern, length)
+        key = WEEKDAY_KEYS[date.wday]
+        case length
+        when 1..3
+          calendar[:days][:format][:abbreviated][key]
+        when 4
+          calendar[:days][:format][:wide][key]
+        when 5
+          calendar[:days][:'stand-alone'][:narrow][key]
+        end
+      end
+
+      def weekday_local(date, pattern, length)
+        # "Like E except adds a numeric value depending on the local starting day of the week"
+        raise 'not implemented (need to defer a country to lookup the local first day of week from weekdata)'
+      end
+
+      def weekday_local_stand_alone(date, pattern, length)
+        raise 'not implemented (need to defer a country to lookup the local first day of week from weekdata)'
+      end
+    end
+  end
+end

data/lib/cldr/format/datetime/base.rb

@@ -0,0 +1,32 @@
+class Cldr
+  module Format
+    class Datetime
+      class Base
+        attr_reader :calendar
+
+        def initialize(format, calendar)
+          @calendar = calendar
+          compile(format)
+        end
+
+        protected
+
+          def compile(format)
+            (class << self; self; end).class_eval <<-code
+              def apply(date, options = {}); #{compile_format(format)}; end
+            code
+          end
+
+          # compile_format("EEEE, d. MMMM y") # =>
+          #   '' + weekday(date, "EEEE", 4) + ', ' + day(date, "d", 1) + '. ' +
+          #        month(date, "MMMM", 4)   + ' ' + year(date, "y", 1) + ''
+          def compile_format(format)
+            "'" + format.gsub(self.class.const_get(:PATTERN)) do |token|
+              method = self.class.const_get(:METHODS)[token[0, 1]]
+              "' + #{method}(date, #{token.inspect}, #{token.length}) + '"
+            end + "'"
+          end
+      end
+    end
+  end
+end

data/lib/cldr/format/datetime.rb

@@ -0,0 +1,28 @@
+class Cldr
+  module Format
+    class Datetime
+      autoload :Base, 'cldr/format/datetime/base'
+
+      attr_reader :date, :time
+
+      def initialize(format, date, time)
+        @date, @time = date, time
+        compile(format)
+      end
+
+      protected
+
+        def compile(format)
+          (class << self; self; end).class_eval <<-code
+            def apply(datetime, options = {}); #{compile_format(format)}; end
+          code
+        end
+        
+        def compile_format(format)
+          "'" + format.gsub(%r(\{(0|1)\})) do |token|
+            "' + #{token == '{0}' ? 'time' : 'date'}.apply(datetime, options) + '"
+          end + "'"
+        end
+    end
+  end
+end

data/lib/cldr/format/decimal/base.rb

@@ -0,0 +1,18 @@
+class Cldr
+  module Format
+    class Decimal
+      class Base
+        def interpolate(string, value, orientation = :right)
+          value  = value.to_s
+          length = value.length
+          start, pad = orientation == :left ? [0, :rjust] : [-length, :ljust]
+
+          string = string.dup
+          string = string.ljust(length, '#') if string.length < length
+          string[start, length] = value
+          string.gsub('#', '')
+        end
+      end
+    end
+  end
+end

data/lib/cldr/format/decimal/fraction.rb

@@ -0,0 +1,28 @@
+class Cldr
+  module Format
+    class Decimal
+      class Fraction < Base
+        attr_reader :format, :decimal, :precision
+
+        def initialize(format, symbols = {})
+          @format  = format ? format.split('.').pop : ''
+          @decimal = symbols[:decimal] || '.'
+          @precision = @format.length
+        end
+
+        def apply(fraction, options = {})
+          precision = options[:precision] || self.precision
+          if precision > 0
+            decimal + interpolate(format(options), fraction, :left)
+          else
+            ''
+          end
+        end
+
+        def format(options)
+          options[:precision] ? '0' * options[:precision] : @format
+        end
+      end
+    end
+  end
+end

data/lib/cldr/format/decimal/integer.rb

@@ -0,0 +1,46 @@
+class Cldr
+  module Format
+    class Decimal
+      class Integer < Base
+        attr_reader :format, :separator, :groups
+
+        def initialize(format, symbols = {})
+          format     = format.split('.')[0]
+          @format    = prepare_format(format, symbols)
+          @groups    = parse_groups(format)
+          @separator = symbols[:group] || ','
+        end
+
+        def apply(number, options = {})
+          format_groups(interpolate(format, number.to_i))
+        end
+
+        def format_groups(string)
+          return string if groups.empty?
+          tokens = []
+          tokens << chop_group(string, groups.first)
+          tokens << chop_group(string, groups.last) while string.length > groups.last
+          tokens << string
+          tokens.compact.reverse.join(separator)
+        end
+
+        def parse_groups(format)
+          return [] unless index = format.rindex(',')
+          rest   = format[0, index]
+          widths = [format.length - index - 1]
+          widths << rest.length - rest.rindex(',') - 1 if rest.rindex(',')
+          widths.compact.uniq
+        end
+
+        def chop_group(string, size)
+          string.slice!(-size, size) if string.length > size
+        end
+
+        def prepare_format(format, symbols)
+          signs = symbols.values_at(:plus_sign, :minus_sign)
+          format.tr(',', '').tr('+-', signs.join)
+        end
+      end
+    end
+  end
+end

data/lib/cldr/format/decimal/number.rb

@@ -0,0 +1,44 @@
+class Cldr
+  module Format
+    class Decimal
+      class Number
+        attr_reader :prefix, :suffix, :integer_format, :fraction_format, :symbols
+
+        DEFAULT_SYMBOLS = { :group => ',', :decimal => '.', :plus_sign => '+', :minus_sign => '-' }
+        FORMAT_PATTERN  = /([^0#,\.]*)([0#,\.]+)([^0#,\.]*)$/
+
+        def initialize(format, symbols = {})
+          @symbols = DEFAULT_SYMBOLS.merge(symbols)
+          @prefix, @suffix, @integer_format, @fraction_format = *parse_format(format, symbols)
+        end
+
+        def apply(number, options = {})
+          int, fraction = parse_number(number, options)
+
+          result =  integer_format.apply(int, options)
+          result << fraction_format.apply(fraction, options) if fraction
+          prefix + result + suffix
+        end
+
+        protected
+
+          def parse_format(format, symbols = {})
+            format =~ FORMAT_PATTERN
+            prefix, suffix, int, fraction = $1.to_s, $3.to_s, *$2.split('.')
+            [prefix, suffix, Integer.new(int, symbols), Fraction.new(fraction, symbols)]
+          end
+
+          def parse_number(number, options = {})
+            precision = options[:precision] || fraction_format.precision
+            number = round_to(number, precision)
+            number.abs.to_s.split('.')
+          end
+
+          def round_to(number, precision)
+            factor = 10 ** precision
+            (number * factor).round.to_f / factor
+          end
+      end
+    end
+  end
+end

data/lib/cldr/format/decimal.rb

@@ -0,0 +1,32 @@
+class Cldr
+  module Format
+    class Decimal
+      autoload :Base,     'cldr/format/decimal/base'
+      autoload :Fraction, 'cldr/format/decimal/fraction'
+      autoload :Integer,  'cldr/format/decimal/integer'
+      autoload :Number,   'cldr/format/decimal/number'
+
+      attr_reader :positive, :negative
+
+      def initialize(format, symbols = {})
+        @positive, @negative = parse_format(format, symbols)
+      end
+
+      def apply(number, options = {})
+        number = Float(number)
+        format = number.abs == number ? positive : negative
+        format.apply(number, options)
+      rescue TypeError, ArgumentError
+        number
+      end
+
+      protected
+
+        def parse_format(format, symbols)
+          formats = format.split(symbols[:list] || ';')
+          formats << "#{symbols[:minus] || '-'}#{format}" if formats.size == 1
+          formats.map { |format| Number.new(format, symbols) }
+        end
+    end
+  end
+end

data/lib/cldr/format/percent.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+class Cldr
+  module Format
+    class Percent < Decimal
+      def apply(number, options = {})
+        super.gsub('¤', options[:percent_sign] || '%')
+      end
+    end
+  end
+end