r18n-core 0.3.2 → 0.4

data/spec/locale_spec.rb

@@ -2,100 +2,138 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe R18n::Locale do
+  before :all do
+    @ru = R18n::Locale.load('ru')
+    @en = R18n::Locale.load('en')
+  end
 
+  it "should return all available locales" do
+    R18n::Locale.available.class.should == Array
+    R18n::Locale.available.should_not be_empty
+  end
+  
   it "should check is locale exists" do
     R18n::Locale.exists?('ru').should be_true
     R18n::Locale.exists?('no-LC').should be_false
   end
+  
+  it "should set locale properties" do
+    locale_class = Class.new(R18n::Locale) do
+      set :one => 1
+      set :two => 2
+    end
+    locale = locale_class.new
+    locale.one.should == 1
+    locale.two.should == 2
+  end
 
   it "should load locale" do
-    locale = R18n::Locale.load('ru')
-    locale.code.should == 'ru'
-    locale.title.should == 'Русский'
-    locale.ltr?.should be_true
+    @ru.class.should == R18n::Locales::Ru
+    @ru.code.should  == 'ru'
+    @ru.title.should == 'Русский'
   end
   
   it "should load locale by Symbol" do
     R18n::Locale.load(:ru).should == R18n::Locale.load('ru')
   end
-  
-  it "should use locale's class" do
-    ru = R18n::Locale.load('ru')
-    ru.class.should == R18n::Locales::Ru
-    
-    eo = R18n::Locale.load('eo')
-    eo.class.should == R18n::Locale
-  end
-
-  it "should include locale by +include+ option" do
-    enUS = R18n::Locale.load('en-US')
-    en = R18n::Locale.load('en')
-    enUS.title.should == 'English (US)'
-    en.title.should == 'English'
-    enUS['week'].should == en['week']
-  end
 
   it "should be equal to another locale with same code" do
-    ru = R18n::Locale.load('ru')
-    en = R18n::Locale.load('en')
-    another_en = R18n::Locale.load('en')
-    en.should_not == ru
-    en.should == another_en
+    @en.should_not == @ru
+    @en.should == R18n::Locale.load('en')
   end
 
   it "should print human readable representation" do
-    R18n::Locale.load('ru').inspect.should == 'Locale ru (Русский)'
-  end
-
-  it "should return all available locales" do
-    R18n::Locale.available.class.should == Array
-    R18n::Locale.available.should_not be_empty
+    @ru.inspect.should == 'Locale ru (Русский)'
   end
 
   it "should return pluralization type by elements count" do
-    locale = R18n::Locale.load('en')
-    locale.pluralize(0).should == 0
-    locale.pluralize(1).should == 1
-    locale.pluralize(5).should == 'n'
+    @en.pluralize(0).should == 0
+    @en.pluralize(1).should == 1
+    @en.pluralize(5).should == 'n'
   end
 
   it "should use UnsupportedLocale if locale file isn't exists" do
-    supported = R18n::Locale.load('en')
-    supported.should be_supported
+    @en.should be_supported
     
     unsupported = R18n::Locale.load('no-LC')
     unsupported.should_not be_supported
     unsupported.should be_a(R18n::UnsupportedLocale)
     
-    unsupported.code.should == 'no-LC'
-    unsupported.title.should == 'no-LC'
+    unsupported.code.downcase.should == 'no-lc'
+    unsupported.title.downcase.should == 'no-lc'
     unsupported.ltr?.should be_true
     
-    unsupported['code'].should == 'no-LC'
-    unsupported['title'].should == 'no-LC'
-    unsupported['direction'].should == 'ltr'
-    
     unsupported.pluralize(5).should == 'n'
-    unsupported.inspect.should == 'Unsupported locale no-LC'
+    unsupported.inspect.downcase.should == 'unsupported locale no-lc'
   end
 
   it "should format number in local traditions" do
-    locale = R18n::Locale.load('en')
-    locale.format_integer(-123456789).should == "−123,456,789"
+    @en.localize(-123456789).should == "−123,456,789"
   end
 
   it "should format float in local traditions" do
-    locale = R18n::Locale.load('en')
-    locale.format_float(-12345.67).should == "−12,345.67"
+    @en.localize(-12345.67).should == "−12,345.67"
   end
 
   it "should translate month, week days and am/pm names in strftime" do
-    locale =  R18n::Locale.load('ru')
+    i18n = R18n::I18n.new 'ru'
     time = Time.at(0).utc
     
-    locale.strftime(time, '%a %A').should == 'Чтв Четверг'
-    locale.strftime(time, '%b %B').should == 'янв января'
-    locale.strftime(time, '%H:%M%p').should == '00:00 утра'
+    @ru.localize(time, '%a %A').should == 'Чтв Четверг'
+    @ru.localize(time, '%b %B').should == 'янв января'
+    @ru.localize(time, '%H:%M%p').should == '00:00 утра'
+  end
+  
+  it "should localize date for human" do
+    i18n = R18n::I18n.new('ru')
+    
+    @ru.localize(Date.today + 2, :human, i18n).should == 'через 2 дня'
+    @ru.localize(Date.today + 1, :human, i18n).should == 'завтра'
+    @ru.localize(Date.today,     :human, i18n).should == 'сегодня'
+    @ru.localize(Date.today - 1, :human, i18n).should == 'вчера'
+    @ru.localize(Date.today - 3, :human, i18n).should == '3 дня назад'
+    
+    y2000 = Date.parse('2000-01-08')
+    @ru.localize(y2000, :human, i18n, y2000 + 8  ).should == ' 8 января'
+    @ru.localize(y2000, :human, i18n, y2000 - 365).should == ' 8 января 2000'
+  end
+  
+  it "should localize times for human" do
+    minute = 60
+    hour   = 60 * minute
+    day    = 24 * hour
+    zero   = Time.at(0).utc
+    params = [:human, R18n::I18n.new('ru'), zero]
+    
+    @ru.localize( zero + 7 * day,     *params).should == ' 8 января 00:00'
+    @ru.localize( zero + 50 * hour,   *params).should == 'через 2 дня 02:00'
+    @ru.localize( zero + 25 * hour,   *params).should == 'завтра 01:00'
+    @ru.localize( zero + 70 * minute, *params).should == 'через 1 час'
+    @ru.localize( zero + 38 * minute, *params).should == 'через 38 минут'
+    @ru.localize( zero + 5,           *params).should == 'сейчас'
+    @ru.localize( zero - 15,          *params).should == 'сейчас'
+    @ru.localize( zero - minute,      *params).should == '1 минуту назад'
+    @ru.localize( zero - 2 * hour,    *params).should == '2 часа назад'
+    @ru.localize( zero - 13 * hour,   *params).should == 'вчера 11:00'
+    @ru.localize( zero - 50 * hour,   *params).should == '3 дня назад 22:00'
+    @ru.localize( zero - 9 * day,     *params).should == '23 декабря 1969 00:00'
+  end
+  
+  it "should use standard formatter by default" do
+    @ru.localize(Time.at(0).utc).should == '01.01.1970 00:00'
+  end
+  
+  it "shouldn't localize time without i18n object" do
+    @ru.localize(Time.at(0)).should_not == Time.at(0).to_s
+    @ru.localize(Time.at(0), :full).should_not == Time.at(0).to_s
+    
+    @ru.localize(Time.at(0), :human).should == Time.at(0).to_s
+  end
+  
+  it "should raise error on unknown formatter" do
+    lambda {
+      @ru.localize(Time.at(0).utc, R18n::I18n.new('ru'), :unknown)
+    }.should raise_error(ArgumentError, /formatter/)
   end
 
   it "should delete slashed from locale for security reasons" do
@@ -113,7 +151,7 @@ describe R18n::Locale do
     upcase = R18n::Locale.load('no-LC')
     downcase = R18n::Locale.load('no-lc')
     upcase.should == downcase
-    upcase.code.should == 'no-LC'
+    upcase.code.should == 'no-lc'
     downcase.code.should == 'no-lc'
   end
 

data/spec/locales/cs_spec.rb

@@ -3,18 +3,20 @@ require File.join(File.dirname(__FILE__), '..', '..', 'locales', 'cs')
 
 describe R18n::Locales::Cs do
   it "should use Czech pluralization" do
-    ru = R18n::Locale.load 'cs'
+    ru = R18n::Locale.load('cs')
     ru.pluralize(0).should == 0
     ru.pluralize(1).should == 1
+    
     ru.pluralize(2).should == 2
     ru.pluralize(3).should == 2
     ru.pluralize(4).should == 2
-    ru.pluralize(5).should == 'n'
-    ru.pluralize(21).should == 'n'
-    ru.pluralize(11).should == 'n'
-    ru.pluralize(12).should == 'n'
-    ru.pluralize(22).should == 'n'
-    ru.pluralize(57).should == 'n'
+    
+    ru.pluralize(5).should   == 'n'
+    ru.pluralize(21).should  == 'n'
+    ru.pluralize(11).should  == 'n'
+    ru.pluralize(12).should  == 'n'
+    ru.pluralize(22).should  == 'n'
+    ru.pluralize(57).should  == 'n'
     ru.pluralize(101).should == 'n'
     ru.pluralize(102).should == 'n'
     ru.pluralize(111).should == 'n'

data/spec/locales/pl_spec.rb

@@ -5,19 +5,18 @@ describe R18n::Locales::Pl do
   it "should use Polish pluralization" do
     pl = R18n::Locale.load 'pl'
     pl.pluralize(0).should == 0
-    
     pl.pluralize(1).should == 1
     
-    pl.pluralize(2).should == 2
-    pl.pluralize(4).should == 2
-    pl.pluralize(22).should == 2
+    pl.pluralize(2).should   == 2
+    pl.pluralize(4).should   == 2
+    pl.pluralize(22).should  == 2
     pl.pluralize(102).should == 2
     
-    pl.pluralize(5).should == 'n'
-    pl.pluralize(11).should == 'n'
-    pl.pluralize(12).should == 'n'
-    pl.pluralize(21).should == 'n'
-    pl.pluralize(57).should == 'n'
+    pl.pluralize(5).should   == 'n'
+    pl.pluralize(11).should  == 'n'
+    pl.pluralize(12).should  == 'n'
+    pl.pluralize(21).should  == 'n'
+    pl.pluralize(57).should  == 'n'
     pl.pluralize(101).should == 'n'
     pl.pluralize(111).should == 'n'
     pl.pluralize(112).should == 'n'

data/spec/locales/ru_spec.rb

@@ -6,19 +6,19 @@ describe R18n::Locales::Ru do
     ru = R18n::Locale.load 'ru'
     ru.pluralize(0).should == 0
     
-    ru.pluralize(1).should == 1
-    ru.pluralize(21).should == 1
+    ru.pluralize(1).should   == 1
+    ru.pluralize(21).should  == 1
     ru.pluralize(101).should == 1
     
-    ru.pluralize(2).should == 2
-    ru.pluralize(4).should == 2
-    ru.pluralize(22).should == 2
+    ru.pluralize(2).should   == 2
+    ru.pluralize(4).should   == 2
+    ru.pluralize(22).should  == 2
     ru.pluralize(102).should == 2
     
-    ru.pluralize(5).should == 'n'
-    ru.pluralize(11).should == 'n'
-    ru.pluralize(12).should == 'n'
-    ru.pluralize(57).should == 'n'
+    ru.pluralize(5).should   == 'n'
+    ru.pluralize(11).should  == 'n'
+    ru.pluralize(12).should  == 'n'
+    ru.pluralize(57).should  == 'n'
     ru.pluralize(111).should == 'n'
   end
 end

data/spec/r18n_spec.rb

@@ -2,24 +2,43 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe R18n do
+  after do
+    R18n.default_loader = R18n::Loader::YAML
+  end
 
-  it "should set I18n for current thread" do
-    i18n = R18n::I18n.new('en', '')
+  it "should store I18n" do
+    i18n = R18n::I18n.new('en')
     R18n.set(i18n)
     R18n.get.should == i18n
+    
+    R18n.set(nil)
+    R18n.get.should be_nil
   end
-
-  it "should merge hash recursively" do
-    a = { :a => 1,
-          :b => {:ba => 1, :bb => 1},
-          :c => 1 }
-    b = { :b => {:bb => 2, :bc => 2},
-          :c => 2 }
+  
+  it "should set setter to I18n" do
+    i18n = R18n::I18n.new('en')
+    R18n.set(i18n)
+    
+    i18n = R18n::I18n.new('ru')
+    R18n.set { i18n }
+    
+    R18n.get.should == i18n
+  end
+  
+  it "should store default loader class" do
+    R18n.default_loader.should == R18n::Loader::YAML
+    R18n.default_loader = Class
+    R18n.default_loader.should == Class
+  end
+  
+  it "should store cache" do
+    R18n.cache.should be_a(Hash)
+    
+    R18n.cache = { 1 => 2 }
+    R18n.cache.should == { 1 => 2 }
     
-    R18n::Utils.deep_merge! a, b
-    a.should == { :a => 1,
-                  :b => { :ba => 1, :bb => 2, :bc => 2 },
-                  :c => 2 }
+    R18n.cache.clear
+    R18n.cache.should == {}
   end
   
   it "should convert Time to Date" do

data/spec/spec_helper.rb

@@ -2,8 +2,32 @@
 require 'rubygems'
 require 'pp'
 
-require File.join(File.dirname(__FILE__), '../lib/r18n-core')
+dir = Pathname(__FILE__).dirname
 
-DIR = Pathname(__FILE__).dirname + 'translations/general' unless defined? DIR
-TWO = Pathname(__FILE__).dirname + 'translations/two' unless defined? TWO
-EXT = Pathname(__FILE__).dirname + 'translations/extension' unless defined? EXT
+require dir + '../lib/r18n-core'
+
+DIR = dir + 'translations/general' unless defined? DIR
+TWO = dir + 'translations/two' unless defined? TWO
+EXT = R18n::Loader::YAML.new(dir + 'translations/extension') unless defined? EXT
+
+gem 'maruku'
+gem 'RedCloth'
+
+class CounterLoader
+  attr_reader :available
+  attr_reader :loaded
+  
+  def initialize(*available)
+    @available = available.map { |i| R18n::Locale.load(i) }
+    @loaded = 0
+  end
+  
+  def load(locale)
+    @loaded += 1
+    {}
+  end
+  
+  def hash
+    @available.hash
+  end
+end

data/spec/translated_spec.rb

@@ -29,7 +29,7 @@ describe R18n::Translated do
     @user_class.translation :name
     user = @user_class.new
     
-    user.name.should be_nil
+    user.name.should_not be_translated
     user.name = 'John'
     user.name.should == 'John'
     

data/spec/translation_spec.rb

@@ -2,88 +2,54 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe R18n::Translation do
-  before :all do
-    @en = R18n::Locale.load('en')
-    @ru = R18n::Locale.load('ru')
-  end
-
-  it "should return all available translations" do
-    R18n::Translation.available(DIR).should =~ ['en', 'no-lc', 'ru']
-    R18n::Translation.available([TWO, DIR]).should =~ [
-        'en', 'fr', 'no-lc', 'ru']
-  end
-
-  it "should load translations" do
-    translation = R18n::Translation.load([@en], DIR)
-    translation.one.should == 'One'
-    translation['one'].should == 'One'
-  end
-
-  it "should find in subtranslations" do
-    translation = R18n::Translation.load([@ru, @en], DIR)
-    translation.one.should == 'Один'
-    translation.two.should == 'Two'
-  end
-
-  it "should return nil if translation isn't found" do
-    translation = R18n::Translation.load([@en], DIR)
-    translation.not.exists.should be_nil
-    translation['not']['exists'].should be_nil
+  
+  it "should return unstranslated string if translation isn't found" do
+    i18n = R18n::I18n.new('en', DIR)
+    i18n.not.exists.should be_a(R18n::Untranslated)
+    i18n.not.exists.should_not be_translated
+    (i18n.not.exists | 'default').should == 'default'
+    
+    (i18n.in | 'default').should == 'default'
+    
+    i18n.one.should be_translated
+    (i18n.one | 'default').should == 'One'
   end
 
   it "should load use hierarchical translations" do
-    translation = R18n::Translation.load([@ru, @en], DIR)
-    translation.in.another.level.should == 'Иерархический'
-    translation['in']['another']['level'].should == 'Иерархический'
-    translation.only.english.should == 'Only in English'
+    i18n = R18n::I18n.new(['ru', 'en'], DIR)
+    i18n.in.another.level.should == 'Иерархический'
+    i18n[:in][:another][:level].should == 'Иерархический'
+    i18n['in']['another']['level'].should == 'Иерархический'
+    i18n.only.english.should == 'Only in English'
   end
   
   it "should save path for translation" do
-    translation = R18n::Translation.load([@en], DIR)
+    i18n = R18n::I18n.new('en', DIR)
     
-    translation.in.another.level.path.should == 'in.another.level'
+    i18n.in.another.level.path.should == 'in.another.level'
     
-    translation.in.another.not.exists.path.should == 'in.another.not.exists'
-    translation.in.another.not.exists.untranslated_path.should == 'not.exists'
-    translation.in.another.not.exists.translated_path.should == 'in.another.'
+    i18n.in.another.not.exists.path.should == 'in.another.not.exists'
+    i18n.in.another.not.exists.untranslated_path.should == 'not.exists'
+    i18n.in.another.not.exists.translated_path.should == 'in.another.'
     
-    translation.not.untranslated_path.should == 'not'
-    translation.not.translated_path.should == ''
+    i18n.not.untranslated_path.should == 'not'
+    i18n.not.translated_path.should == ''
   end
 
   it "should return string with locale info" do
-    translation = R18n::Translation.load([R18n::Locale.load('no-LC'), @en], DIR)
-    translation.one.locale.should == R18n::UnsupportedLocale.new('no-LC')
-    translation.two.locale.should == R18n::Locale.load('en')
-  end
-
-  it "should load translations from several dirs" do
-    tr = R18n::Translation.load([R18n::Locale.load('no-LC'), @en], [TWO, DIR])
-    tr.in.two.should == 'Two'
-    tr.in.another.level.should == 'Hierarchical'
-  end
-
-  it "should use extension translations" do
-    R18n::Translation.extension_translations << EXT
-    
-    translation = R18n::Translation.load([@en], DIR)
-    translation.ext.should == 'Extension'
-    translation.one.should == 'One'
-  end
-
-  it "shouldn't use extension without app translations with same locale" do
-    R18n::Translation.extension_translations << EXT
-    
-    translation = R18n::Translation.load([R18n::Locale.load('no-TR'), @en], DIR)
-    translation.ext.should == 'Extension'
+    i18n = R18n::I18n.new(['no-LC', 'en'], DIR)
+    i18n.one.locale.should == R18n::UnsupportedLocale.new('no-LC')
+    i18n.two.locale.should == R18n::Locale.load('en')
   end
   
-  it "should ignore case on loading" do
-    translation = R18n::Translation.load([R18n::Locale.load('no-lc')], [DIR])
-    translation.one.should == 'ONE'
+  it "should filter typed data" do
+    en = R18n::Locale.load('en')
+    translation = R18n::Translation.new(en, '', en, {
+      'count' => R18n::Typed.new('pl', { 1 => 'one', 'n' => 'many' })
+    })
     
-    translation = R18n::Translation.load([R18n::Locale.load('no-LC')], [DIR])
-    translation.one.should == 'ONE'
+    translation.count(1).should == 'one'
+    translation.count(5).should == 'many'
   end
 
 end

data/spec/translations/two/en.yml

@@ -1,3 +1,2 @@
 in:
-  another: Wrong
   two: Two

data/spec/yaml_loader_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe R18n::Loader::YAML do
+  before do
+    @loader = R18n::Loader::YAML.new(DIR)
+  end
+  
+  it "should return dir with translations" do
+    @loader.dir.should == DIR.expand_path.to_s
+  end
+  
+  it "should be equal to another YAML loader with same dir" do
+    @loader.should == R18n::Loader::YAML.new(DIR)
+    @loader.should_not == Class.new(R18n::Loader::YAML).new(DIR)
+  end
+  
+  it "should return all available translations" do
+    @loader.available.should =~ [R18n::Locale.load('ru'),
+                                 R18n::Locale.load('en'),
+                                 R18n::Locale.load('no-lc')]
+  end
+  
+  it "should load translation" do
+    @loader.load(R18n::Locale.load('ru')).should == {
+      'one' => 'Один', 'in' => {'another' => {'level' => 'Иерархический'}} }
+  end
+  
+  it "should return hash by dir" do
+    @loader.hash.should == R18n::Loader::YAML.new(DIR).hash
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: r18n-core
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: "0.4"
 platform: ruby
 authors: 
 - Andrey "A.I." Sitnik
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-29 00:00:00 +03:00
+date: 2010-01-03 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
-description: "    R18n is a i18n tool to translate your Ruby application.\n    It can format numbers and time to the rules of the user locale,\n    has translation for common words, storage translation in YAML format with\n    pluralization, procedures and user filters and has special support for\n    countries with two official languages.\n"
+description: "    R18n is a i18n tool to translate your Ruby application.\n    It has nice Ruby-style syntax, filters, flexible locales, custom loaders,\n    translation support for any classes, time and number localization, several\n    user language support, agnostic core package with out-of-box support for\n    Rails, Sinatra, Merb and desktop applications.\n"
 email: andrey@sitnik.ru
 executables: []
 
@@ -39,6 +39,7 @@ files:
 - lib/r18n-core.rb
 - lib/r18n-core/filters.rb
 - lib/r18n-core/untranslated.rb
+- lib/r18n-core/yaml_loader.rb
 - lib/r18n-core/version.rb
 - lib/r18n-core/utils.rb
 - lib/r18n-core/translated_string.rb
@@ -49,24 +50,17 @@ files:
 - lib/r18n-core/i18n.rb
 - locales/it.rb
 - locales/pl.rb
-- locales/kk.yml
-- locales/it.yml
 - locales/en.rb
-- locales/ru.yml
-- locales/pl.yml
 - locales/cs.rb
-- locales/de.yml
-- locales/eo.yml
+- locales/es.rb
+- locales/kk.rb
 - locales/en-us.rb
-- locales/en-us.yml
-- locales/pt-br.yml
-- locales/cs.yml
-- locales/es.yml
-- locales/fr.yml
+- locales/zh.rb
 - locales/fr.rb
 - locales/ru.rb
-- locales/en.yml
-- locales/zh.yml
+- locales/pt-br.rb
+- locales/de.rb
+- locales/eo.rb
 - LICENSE
 - ChangeLog
 - README.rdoc
@@ -109,6 +103,7 @@ test_files:
 - spec/locales/en-us_spec.rb
 - spec/spec_helper.rb
 - spec/r18n_spec.rb
+- spec/yaml_loader_spec.rb
 - spec/translation_spec.rb
 - spec/translations/general/ru.yml
 - spec/translations/general/en.yml

data/locales/cs.yml

@@ -1,26 +0,0 @@
-title: Český
-code: cs
-sublocales: [cz, sk]
-direction: ltr
-
-week:
-  start: monday
-  days: [Neděle, Pondělí, Úterý, Středa, Čtvrtek, Pátek, Sobota]
-  abbrs: [Ne, Po, Út, St, Čt, Pá, So]
-
-months:
-  names: [Ledna, Února, Března, Dubna, Května, Června, Července, Srpna, Září, Října, Listopadu, Prosince]
-  abbrs: [Led, Úno, Bře, Dub, Kvě, Čer, Čvc, Srp, Zář, Říj, Lis, Pro]
-  standalone: [Leden, Únor, Březen, Duben, Květen, Červen, Červenec, Srpen, Září, Říjen, Listopad, Prosinec]
-
-time:
-  am: dop.
-  pm: odp.
-  time: " %H:%M"
-  date: "%d.%m.%Y"
-  full: "%e %B"
-  year: "_ %Y"
-
-numbers:
-  decimal_separator: ","
-  group_delimiter: " "