ruby-cldr 0.0.1 → 0.0.2

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

@@ -1,113 +0,0 @@
-require 'rubygems'
-require 'rexml/document'
-
-class Cldr
-  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/
-              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})"
-            else
-              op
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cldr/data/territories.rb

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

data/lib/cldr/data/timezones.rb

@@ -1,25 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-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/test/data/plurals_test.rb

@@ -1,132 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-class TestCldrDataPluralParser < Test::Unit::TestCase
-  def cldr_data
-    File.read(File.dirname(__FILE__) + '/../../vendor/cldr/common/supplemental/plurals.xml')
-  end
-  
-  def cldr_rules
-    Cldr::Data::Plurals::Rules.parse(cldr_data)
-  end
-  
-  def test_compiles_to_valid_ruby_code
-    assert_nothing_raised { eval(cldr_rules.to_ruby) }
-  end
-  
-  def test_evals_to_a_hash_containing_plural_rule_and_keys_per_locale
-    data = eval(cldr_rules.to_ruby)
-    assert Hash === data
-    assert Proc === data[:de][:i18n][:plural][:rule]
-    assert_equal [:one, :other], data[:de][:i18n][:plural][:keys]
-  end
-  
-  def test_lookup_rule_by_locale
-    assert_equal "lambda { |n| n == 1 ? :one : :other }", cldr_rules.rule(:de).to_ruby
-  end
-
-  def test_parses_n
-    assert Cldr::Data::Plurals::Rule.parse('n').is_a?(Cldr::Data::Plurals::Expression)
-  end
-
-  def test_parses_n_is_1
-    rule = Cldr::Data::Plurals::Rule.parse('n is 1')
-    assert_equal [:is, '1'], [rule.operator, rule.operand]
-  end
-
-  def test_parses_n_mod_1_is_1
-    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 is 1')
-    assert_equal [:is, '1', '1'], [rule.operator, rule.operand, rule.mod]
-  end
-
-  def test_parses_n_is_not_1
-    rule = Cldr::Data::Plurals::Rule.parse('n is not 1')
-    assert_equal [:is, '1', true], [rule.operator, rule.operand, rule.negate]
-  end
-
-  def test_parses_n_mod_1_is_not_1
-    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 is not 1')
-    assert_equal [:is, '1', true, '1'], [rule.operator, rule.operand, rule.negate, rule.mod]
-  end
-
-  def test_parses_n_in_1_2
-    rule = Cldr::Data::Plurals::Rule.parse('n in 1..2')
-    assert_equal [:in, '[1, 2]'], [rule.operator, rule.operand]
-  end
-
-  def test_parses_n_mod_1_in_1_2
-    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 in 1..2')
-    assert_equal [:in, '[1, 2]', '1'], [rule.operator, rule.operand, rule.mod]
-  end
-
-  def test_parses_n_not_in_1_2
-    rule = Cldr::Data::Plurals::Rule.parse('n not in 1..2')
-    assert_equal [:in, '[1, 2]', true], [rule.operator, rule.operand, rule.negate]
-  end
-
-  def test_parses_n_mod_1_not_in_1_2
-    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 not in 1..2')
-    assert_equal [:in, '[1, 2]', true, '1'], [rule.operator, rule.operand, rule.negate, rule.mod]
-  end
-
-  def test_parses_or_condition
-    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 is not 2 or n mod 2 in 3..4')
-    assert_equal 2, rule.size
-    assert_equal [:is, '2', true, '1'], [rule[0].operator, rule[0].operand, rule[0].negate, rule[0].mod]
-    assert_equal [:in, '[3, 4]', false, '2'], [rule[1].operator, rule[1].operand, rule[1].negate, rule[1].mod]
-  end
-
-  def test_parses_and_condition
-    rule = Cldr::Data::Plurals::Rule.parse('n mod 1 is not 2 and n mod 2 in 3..4')
-    assert_equal 2, rule.size
-    assert_equal [:is, '2', true, '1'], [rule[0].operator, rule[0].operand, rule[0].negate, rule[0].mod]
-    assert_equal [:in, '[3, 4]', false, '2'], [rule[1].operator, rule[1].operand, rule[1].negate, rule[1].mod]
-  end
-
-  def test_compiles_n
-    assert_equal 'n', Cldr::Data::Plurals::Rule.parse('n').to_ruby
-  end
-
-  def test_compiles_n_is_2
-    assert_equal 'n == 2', Cldr::Data::Plurals::Rule.parse('n is 2').to_ruby
-  end
-
-  def test_compiles_n_mod_1_is_2
-    assert_equal 'n % 1 == 2', Cldr::Data::Plurals::Rule.parse('n mod 1 is 2').to_ruby
-  end
-
-  def test_compiles_n_is_not_2
-    assert_equal 'n != 2', Cldr::Data::Plurals::Rule.parse('n is not 2').to_ruby
-  end
-
-  def test_compiles_n_mod_1_is_not_2
-    assert_equal 'n % 1 != 2', Cldr::Data::Plurals::Rule.parse('n mod 1 is not 2').to_ruby
-  end
-
-  def test_compiles_n_in_1_2
-    assert_equal '[1, 2].include?(n)', Cldr::Data::Plurals::Rule.parse('n in 1..2').to_ruby
-  end
-
-  def test_compiles_n_mod_1_in_1_2
-    assert_equal '[1, 2].include?(n % 1)', Cldr::Data::Plurals::Rule.parse('n mod 1 in 1..2').to_ruby
-  end
-
-  def test_compiles_n_not_in_1_2
-    assert_equal '![1, 2].include?(n)', Cldr::Data::Plurals::Rule.parse('n not in 1..2').to_ruby
-  end
-
-  def test_compiles_n_mod_1_not_in_1_2
-    assert_equal '![1, 2].include?(n % 1)', Cldr::Data::Plurals::Rule.parse('n mod 1 not in 1..2').to_ruby
-  end
-
-  def test_compiles_or_condition
-    assert_equal 'n % 1 != 2 || [3, 4].include?(n % 2)', Cldr::Data::Plurals::Rule.parse('n mod 1 is not 2 or n mod 2 in 3..4').to_ruby
-  end
-
-  def test_compiles_and_condition
-    assert_equal 'n % 1 != 2 && [3, 4].include?(n % 2)', Cldr::Data::Plurals::Rule.parse('n mod 1 is not 2 and n mod 2 in 3..4').to_ruby
-  end
-
-  def test_compiles_n_mod_100_in_3_99
-    assert_equal '[3, 4, 5, 6].include?(n % 100)', Cldr::Data::Plurals::Rule.parse('n mod 100 in 3..6').to_ruby
-  end
-end

data/test/formats/datetime/all.rb

@@ -1,3 +0,0 @@
-Dir["#{File.dirname(__FILE__)}/**/*_test.rb"].each do |filename|
-  require filename
-end

data/test/formats/datetime/date_test.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-require File.dirname(__FILE__) + '/../../test_helper'
-require 'date'
-
-class TestCldrDateFormat < Test::Unit::TestCase
-  def setup
-    @locale = :de
-    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
-  end
-
-  def format(object, pattern)
-    Cldr::Format::Date.new(pattern, @calendar).apply(object)
-  end
-  
-  define_method "test: full date pattern :de" do
-    assert_equal 'Montag, 11. Januar 2010', format(Date.new(2010, 1, 11), 'EEEE, d. MMMM y')
-  end
-
-  define_method "test: long date pattern :de" do
-    assert_equal '11. Januar 2010', format(Date.new(2010, 1, 11), 'd. MMMM y')
-  end
-
-  define_method "test: medium date pattern :de" do
-    assert_equal '11.01.2010', format(Date.new(2010, 1, 11), 'dd.MM.yyyy')
-  end
-
-  define_method "test: short date pattern :de" do
-    assert_equal '11.01.10', format(Date.new(2010, 1, 11), 'dd.MM.yy')
-  end
-end

data/test/formats/datetime/datetime_test.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require File.dirname(__FILE__) + '/../../test_helper'
-require 'date'
-
-class TestCldrDatetimeFormat < Test::Unit::TestCase
-  def setup
-    @locale = :de
-    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
-  end
-  
-  define_method "test: datetime pattern :de" do
-    date   = Cldr::Format::Date.new('dd.MM.yyyy', @calendar)
-    time   = Cldr::Format::Time.new('HH:mm', @calendar)
-    result = Cldr::Format::Datetime.new('{1} {0}', date, time).apply(DateTime.new(2010, 1, 10, 13, 12, 11))
-    assert_equal '10.01.2010 13:12', result
-  end
-end

data/test/formats/datetime/day_test.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-require File.dirname(__FILE__) + '/../../test_helper'
-require 'date'
-
-class TestCldrDateDayFormat < Test::Unit::TestCase
-  def setup
-    @locale = :de
-    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
-  end
-
-  def format(object, pattern)
-    Cldr::Format::Date.new(pattern, @calendar).apply(object)
-  end
-
-  # DAY
-
-  define_method "test: pattern d" do
-    assert_equal  '1', format(Date.new(2010, 1,  1), 'd')
-    assert_equal '10', format(Date.new(2010, 1, 10), 'd')
-  end
-
-  define_method "test: pattern dd" do
-    assert_equal '01', format(Date.new(2010, 1,  1), 'dd')
-    assert_equal '10', format(Date.new(2010, 1, 10), 'dd')
-  end
-
-  define_method "test: pattern E, EE, EEE" do
-    assert_equal 'Fr.', format(Date.new(2010, 1, 1), 'E')
-    assert_equal 'Fr.', format(Date.new(2010, 1, 1), 'EE')
-    assert_equal 'Fr.', format(Date.new(2010, 1, 1), 'EEE')
-  end
-
-  define_method "test: pattern EEEE" do
-    assert_equal 'Freitag', format(Date.new(2010, 1, 1), 'EEEE')
-  end
-
-  define_method "test: pattern EEEEE" do
-    assert_equal 'F', format(Date.new(2010, 1, 1), 'EEEEE')
-  end
-end

data/test/formats/datetime/hour_test.rb

@@ -1,79 +0,0 @@
-# encoding: utf-8
-
-require File.dirname(__FILE__) + '/../../test_helper'
-require 'date'
-
-class TestCldrDateHourFormat < Test::Unit::TestCase
-  def setup
-    @locale = :de
-    @calendar = Cldr::Data::Calendars.new(@locale)[:calendars][:gregorian]
-  end
-
-  def format(object, pattern)
-    Cldr::Format::Time.new(pattern, @calendar).apply(object)
-  end
-
-  define_method "test: h" do
-    assert_equal '12', format(Time.local(2000, 1, 1,  0, 1, 1), 'h')
-    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'h')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'h')
-    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'h')
-    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'h')
-  end
-
-  define_method "test: hh" do
-    assert_equal '12', format(Time.local(2000, 1, 1,  0, 1, 1), 'hh')
-    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'hh')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'hh')
-    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'hh')
-    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'hh')
-  end
-
-  define_method "test: H" do
-    assert_equal  '0', format(Time.local(2000, 1, 1,  0, 1, 1), 'H')
-    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'H')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'H')
-    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'H')
-    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'H')
-  end
-
-  define_method "test: HH" do
-    assert_equal '00', format(Time.local(2000, 1, 1,  0, 1, 1), 'HH')
-    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'HH')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'HH')
-    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'HH')
-    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'HH')
-  end
-
-  define_method "test: K" do
-    assert_equal  '0', format(Time.local(2000, 1, 1,  0, 1, 1), 'K')
-    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'K')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'K')
-    assert_equal  '0', format(Time.local(2000, 1, 1, 12, 1, 1), 'K')
-    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'K')
-  end
-
-  define_method "test: KK" do
-    assert_equal '00', format(Time.local(2000, 1, 1,  0, 1, 1), 'KK')
-    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'KK')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'KK')
-    assert_equal '00', format(Time.local(2000, 1, 1, 12, 1, 1), 'KK')
-    assert_equal '11', format(Time.local(2000, 1, 1, 23, 1, 1), 'KK')
-  end
-
-  define_method "test: k" do
-    assert_equal '24', format(Time.local(2000, 1, 1,  0, 1, 1), 'k')
-    assert_equal  '1', format(Time.local(2000, 1, 1,  1, 1, 1), 'k')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'k')
-    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'k')
-    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'k')
-  end
-
-  define_method "test: kk" do
-    assert_equal '24', format(Time.local(2000, 1, 1,  0, 1, 1), 'kk')
-    assert_equal '01', format(Time.local(2000, 1, 1,  1, 1, 1), 'kk')
-    assert_equal '11', format(Time.local(2000, 1, 1, 11, 1, 1), 'kk')
-    assert_equal '12', format(Time.local(2000, 1, 1, 12, 1, 1), 'kk')
-    assert_equal '23', format(Time.local(2000, 1, 1, 23, 1, 1), 'kk')
-  end
-end