ruby-cldr 0.0.1 → 0.0.2

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

@@ -0,0 +1,119 @@
+require 'rubygems'
+require 'rexml/document'
+
+module Cldr
+  module Export
+    module Data
+      class Plurals
+        class Rules < Array
+          class << self
+            def parse(xml)
+              rules = new
+              REXML::Document.new(xml).elements.each('//pluralRules') do |tag|
+                rule = Rule.new(tag.attributes['locales'].split(/\s+/))
+                tag.elements.each('pluralRule') { |tag| rule << [tag.attributes['count'], tag.text] }
+                rules << rule
+              end
+              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|
+              rule = self.rule(locale)
+              ruby = "{ :plural => { :keys => #{rule.keys.inspect}, :rule => #{rule.to_ruby} } }"
+              ruby = namespaces.reverse.inject(ruby) { |ruby, namespace| "{ #{namespace.inspect} => #{ruby} }"}
+              "#{locale.inspect} => #{ruby}"
+            end.join(",\n")
+            code = code.split("\n").map { |line| "  #{line}" }.join("\n")
+            "{\n" + code + "\n}"
+          end
+        end
+    
+        class Rule < Array
+          class << self
+            def parse(code)
+              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/
+                Expression.new
+              else
+                raise "can not parse #{code}"
+              end
+            end
+          end
+
+          attr_reader :locales
+
+          def initialize(locales)
+            @locales = locales.map { |locale| locale.gsub('_', '-').to_sym }
+          end
+      
+          def keys
+            inject([]) { |keys, (key, code)| keys << key.to_sym } << :other
+          end
+      
+          def to_ruby
+            @condition ||= 'lambda { |n| ' + reverse.inject(':other') do |result, (key, code)|
+              code = self.class.parse(code).to_ruby
+              "#{code} ? :#{key} : #{result}"
+            end + ' }'
+          end
+        end
+
+        class Proposition < Array
+          def initialize(type = nil)
+            @type = type
+          end
+
+          def to_ruby
+            @ruby ||= map { |expr| expr.to_ruby }.join(" #{@type} ")
+          end
+        end
+
+        class Expression
+          attr_reader :operator, :operand, :mod, :negate
+
+          def initialize(operator = nil, mod = nil, negate = nil, operand = nil)
+            @operator, @mod, @negate, @operand = operator, mod, negate, operand
+          end
+
+          def to_ruby
+            @ruby ||= begin
+              op = 'n'
+              op << " % #{@mod}" if mod
+              case @operator
+              when :is
+                op + (@negate ? ' != ' : ' == ') + @operand
+              when :in
+                (@negate ? '!' : '') + "#{@operand}.include?(#{op})"
+              when :within
+                "#{op}.between?(#{@operand.first}, #{@operand.last})" 
+              else
+                op
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Cldr
+  module Export
+    module Data
+      class Territories < Base
+        def initialize(locale)
+          super
+          update(:territories => territories)
+        end
+
+        def territories
+          @territories ||= select('localeDisplayNames/territories/territory').inject({}) do |result, node|
+            result[node.attribute('type').value.to_sym] = node.content unless draft?(node)
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# I probably don't really get timezones.
+
+module Cldr
+  module Export
+    module Data
+      class Timezones < Base
+        def initialize(locale)
+          super
+          update(: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
+end

data/lib/cldr/export/data/units.rb

@@ -0,0 +1,29 @@
+module Cldr
+  module Export
+    module Data
+      class Units < Base
+        def initialize(locale)
+          super
+          update(: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|
+            alt = node.attribute('alt') ? node.attribute('alt').value.to_sym : :default
+            count = node.attribute('count') ? node.attribute('count').value.to_sym : :one
+            result[alt] ||= {}
+            result[alt][count] = node.content unless draft?(node)
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cldr/export/ruby.rb

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Export
     class Ruby
       def export(locale, component, options = {})

data/lib/cldr/export/yaml.rb

@@ -1,6 +1,6 @@
 require 'ya2yaml'
 
-class Cldr
+module Cldr
   module Export
     class Yaml < Ya2YAML
       def initialize

data/lib/cldr/format.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'core_ext/string/camelize'
 
-class Cldr
+module Cldr
   module Format
     autoload :Base,     'cldr/format/base'
     autoload :Currency, 'cldr/format/currency'
@@ -13,101 +13,5 @@ class Cldr
     autoload :Numeric,  'cldr/format/numeric'
     autoload :Percent,  'cldr/format/percent'
     autoload :Time,     'cldr/format/time'
-
-    def format(locale, object, options = {})
-      type = options.has_key?(:currency) ? :currency : options.delete(:as)
-      type ||= guess_type(object)
-
-      send(:"format_#{type}", locale, object, options)
-    end
-
-    def format_decimal(locale, number, options = {})
-      formatter(locale, :decimal, options.delete(:format)).apply(number, options)
-    end
-    alias :format_number :format_decimal
-
-    def format_integer(locale, number, options = {})
-      format_number(number, options.merge(:precision => 0))
-    end
-    alias :format_int :format_integer
-
-    def format_currency(locale, number, options = {})
-      if options[:currency].is_a?(Symbol)
-        options.merge!(:currency => lookup_currency(locale, options[:currency], number))
-      end
-      formatter(locale, :currency, options.delete(:format)).apply(number, options)
-    end
-
-    def format_percent(locale, number, options = {})
-      formatter(locale, :percent, options.delete(:format)).apply(number, options)
-    end
-
-    def format_date(locale, date, options = {})
-      formatter(locale, :date, options.delete(:format)).apply(date, options)
-    end
-
-    def format_time(locale, time, options = {})
-      formatter(locale, :time, options.delete(:format)).apply(time, options)
-    end
-
-    def format_datetime(locale, datetime, options = {})
-      format = options.delete(:format) || :default
-      (@formatters ||= {})[:"#{locale}.datetime.#{format}"] ||= begin
-        date = formatter(locale, :date, options.delete(:date_format) || format)
-        time = formatter(locale, :time, options.delete(:time_format) || format)
-        format = lookup_format(locale, :datetime, format)
-        Cldr::Format::Datetime.new(format, date, time).apply(datetime, options)
-      end
-    end
-
-    protected
-
-      def guess_type(object)
-        case object
-        when ::Numeric
-          :number
-        when ::Date, ::DateTime, ::Time
-          object.class.name.downcase
-        else
-          raise_unspecified_format_type!
-        end
-      end
-
-      def formatter(locale, type, format)
-        (@formatters ||= {})[:"#{locale}.#{type}.#{format}"] ||= begin
-          format = lookup_format(locale, type, format)
-          data   = lookup_format_data(locale, type)
-          Cldr::Format.const_get(type.to_s.camelize).new(format, data)
-        end
-      end
-
-      def lookup_format(locale, type, format)
-        # Lookup the format string for the given type (e.g. :number).
-        raise_abstract!
-      end
-
-      def lookup_format_data(locale, type)
-        # Lookup the format data required for the given type (e.g. number
-        # symbols for type :number, calendar data for type :date etc.).
-        raise_abstract!
-      end
-
-      def lookup_currency(locale, currency, count)
-        # Lookup the currency representation for the given locale and amount.
-        # This might be a translation.
-        raise_abstract!
-      end
-
-      def raise_unspecified_format_type!
-        raise ArgumentError.new("You have to specify a format type, e.g. :as => :number.")
-      end
-
-      def raise_unspecified_currency!
-        raise ArgumentError.new("You have to specify a currency, e.g. :currency => 'EUR'.")
-      end
-
-      def raise_abstract!
-        raise "you have to implement this method"
-      end
   end
 end

data/lib/cldr/format/currency.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-class Cldr
+module Cldr
   module Format
     class Currency < Decimal
       def apply(number, options = {})

data/lib/cldr/format/date.rb

@@ -1,4 +1,4 @@
-class Cldr
+module 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}/

data/lib/cldr/format/datetime.rb

@@ -1,28 +1,24 @@
-class Cldr
+module Cldr
   module Format
     class Datetime
       autoload :Base, 'cldr/format/datetime/base'
 
-      attr_reader :date, :time
-
+      attr_reader :format, :date, :time
+      
       def initialize(format, date, time)
-        @date, @time = date, time
-        compile(format)
+        @format, @date, @time = format, date, time
       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 + "'"
+      
+      def apply(datetime, options = {})
+        format.gsub(/(\{\{(date|time)\}\})/) do
+          case $2
+          when 'date'
+            options[:date] || date.apply(datetime, options)
+          when 'time'
+            options[:time] || time.apply(datetime, options)
+          end
         end
+      end
     end
   end
 end

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

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Format
     class Datetime
       class Base

data/lib/cldr/format/decimal.rb

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Format
     class Decimal
       autoload :Base,     'cldr/format/decimal/base'

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

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Format
     class Decimal
       class Base

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

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Format
     class Decimal
       class Fraction < Base

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

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Format
     class Decimal
       class Integer < Base

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

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Format
     class Decimal
       class Number

data/lib/cldr/format/percent.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-class Cldr
+module Cldr
   module Format
     class Percent < Decimal
       def apply(number, options = {})

data/lib/cldr/format/time.rb

@@ -1,4 +1,4 @@
-class Cldr
+module Cldr
   module Format
     class Time < Datetime::Base
       PATTERN = /a{1}|h{1,2}|H{1,2}|K{1,2}|k{1,2}|m{1,2}|s{1,2}|S+|z{1,4}|Z{1,4}/