r18n-core 0.2.3 → 0.3

data/spec/filters_spec.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe R18n::Filters do
+  before do
+    @system  = R18n::Filters.defined.values
+    @enabled = R18n::Filters.defined.values.reject { |i| !i.enabled? }
+    @i18n = R18n::I18n.new('en', DIR)
+  end
+  
+  after do
+    R18n::Filters.defined.values.each do |filter|
+      next if @system.include? filter
+      R18n::Filters.delete(filter)
+    end
+    
+    @enabled.each { |i| R18n::Filters.on(i) unless i.enabled? }
+    (@system - @enabled).each { |i| R18n::Filters.off(i) if i.enabled? }
+  end
+  
+  it "should add new filter" do
+    filter = R18n::Filters.add('my', :my_filter) { |i, config| i }
+    
+    filter.should be_a(R18n::Filters::Filter)
+    filter.name.should == :my_filter
+    filter.type.should == 'my'
+    filter.should be_enabled
+    
+    R18n::Filters.defined.should have_key(:my_filter)
+    @i18n.my_filter.should == 'value'
+    @i18n.my_tree_filter.should == {'name' => 'value'}
+  end
+  
+  it "should use cascade filters" do
+    filter = R18n::Filters.add('my', :one)      { |i, config| i + '1' }
+    filter = R18n::Filters.add('my', :two)      { |i, config| i + '2' }
+    filter = R18n::Filters.add('my', :three, 0) { |i, config| i + '3' }
+    @i18n.my_filter.should == 'value312'
+  end
+  
+  it "should return name for nameless filter" do
+    R18n::Filters.instance_variable_set(:@last_auto_name, 0)
+    
+    R18n::Filters.add('some').name.should == 1
+    R18n::Filters.add('some').name.should == 2
+    
+    R18n::Filters.add('some', 3)
+    R18n::Filters.add('some').name.should == 4
+  end
+  
+  it "should delete filter by name" do
+    R18n::Filters.add('my', :my_filter) { '1' }
+    @i18n.my_filter.should == '1'
+    
+    R18n::Filters.delete(:my_filter)
+    R18n::Filters.defined.should_not have_key(:my_filter)
+    @i18n.my_filter.should == 'value'
+  end
+  
+  it "should delete filter by object" do
+    filter = R18n::Filters.add('my') { '1' }
+    @i18n.my_filter.should == '1'
+    
+    R18n::Filters.delete(filter)
+    R18n::Filters.defined.should_not have_key(filter.name)
+    @i18n.my_filter.should == 'value'
+  end
+  
+  it "should use global filters" do
+    R18n::Filters.add(String) { |result, config, a, b| result + a + b }
+    R18n::Filters.add(String) { |result, config| result + '!' }
+    
+    @i18n.one('1', '2').should == 'One12!'
+  end
+  
+  it "should turn off filter" do
+    filter = R18n::Filters.add('my', :one) { |i, config| i + '1' }
+    filter = R18n::Filters.add('my', :two) { |i, config| i + '2' }
+    
+    R18n::Filters.off(:one)
+    R18n::Filters.defined[:one].should_not be_enabled
+    @i18n.my_filter.should == 'value2'
+    
+    R18n::Filters.on(:one)
+    R18n::Filters.defined[:one].should be_enabled
+    @i18n.my_filter.should == 'value12'
+  end
+  
+  it "should send config to filter" do
+    R18n::Filters.add('my') do |i, config|
+      config.secret_value = 1
+      config
+    end
+    @i18n.my_filter.locale.should == @i18n.locale
+    @i18n.my_filter.path.should == 'my_filter'
+    @i18n.my_filter.secret_value.should == 1
+    @i18n.my_filter.unknown_value.should be_nil
+  end
+  
+  it "should use one config for cascade filters" do
+    R18n::Filters.add('my') { |content, config| config.new_secret ? 2 : 1 }
+    @i18n.my_filter.should == 1
+    
+    R18n::Filters.add('my', nil, 0) do |content, config|
+      config.new_secret = true
+      content
+    end
+    @i18n.my_filter.should == 2
+  end
+  
+  it "should send parameters to filter" do
+    R18n::Filters.add('my') { |i, config, a, b| "#{i}#{a}#{b}" }
+    @i18n['my_filter', 1, 2].should == 'value12'
+    @i18n.my_filter(1, 2).should == 'value12'
+  end
+
+  it "should call proc from translation" do
+    @i18n.sum(2, 3).should == 5
+  end
+
+  it "should pluralize translation" do
+    @i18n.comments(0, 'article').should == 'no comments for article'
+    @i18n.comments(1, 'article').should == 'one comment for article'
+    @i18n.comments(5, 'article').should == '5 comments for article'
+    
+    @i18n.files(0).should == '0 files'
+    @i18n.files(-5.5).should == '−5.5 files'
+    @i18n.files(5000).should == '5,000 files'
+  end
+
+  it "should pluralize translation without locale" do
+    i18n = R18n::I18n.new('no-LC', DIR)
+    i18n.entries(1).should == 'ONE'
+    i18n.entries(5).should == 'N'
+  end
+
+  it "should can use params in translation" do
+    @i18n.params(-1, 2).should == 'Is −1 between −1 and 2?'
+  end
+  
+  it "should have filter for escape HTML" do
+    @i18n.html.should == '<script>true && false</script>'
+  end
+  
+  it "should have disabled global filter for escape HTML" do
+    @i18n.greater.should == '1 < 2 is true'
+    
+    R18n::Filters.on(:global_escape_html)
+    @i18n.greater.should == '1 &lt; 2 is true'
+    @i18n.html.should == '&lt;script&gt;true &amp;&amp; false&lt;/script&gt;'
+  end
+  
+  it "should have filter to disable global HTML escape" do
+    @i18n.no_escape.should == '<b>Warning</b>'
+    R18n::Filters.on(:global_escape_html)
+    @i18n.no_escape.should == '<b>Warning</b>'
+  end
+  
+  it "should have Markdown filter" do
+    @i18n.markdown.should == '<p><strong>Hi!</strong></p>'
+  end
+  
+  it "should have Textile filter" do
+    @i18n.textile.should == '<p><em>Hi!</em></p>'
+  end
+  
+end

data/spec/i18n_spec.rb

@@ -2,6 +2,9 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe R18n::I18n do
+  after do
+    R18n::I18n.default = 'en'
+  end
 
   it "should parse HTTP_ACCEPT_LANGUAGE" do
     R18n::I18n.parse_http(nil).should == []
@@ -19,14 +22,16 @@ describe R18n::I18n do
     i18n = R18n::I18n.new('en', DIR)
     i18n.locales.should == [R18n::Locale.load('en')]
   
-    i18n = R18n::I18n.new(['ru', 'no_LC'], DIR)
+    i18n = R18n::I18n.new(['ru', 'no-LC'], DIR)
     i18n.locales.should == [R18n::Locale.load('ru'),
-                            R18n::UnsupportedLocale.new('no_LC')]
+                            R18n::UnsupportedLocale.new('no-LC'),
+                            R18n::UnsupportedLocale.new('no'),
+                            R18n::UnsupportedLocale.new('en')]
   end
 
   it "should return translations dir" do
     i18n = R18n::I18n.new('en', DIR)
-    i18n.translations_dirs.expand_path.to_s.should == DIR.expand_path.to_s
+    i18n.translation_dirs.expand_path.to_s.should == DIR.expand_path.to_s
   end
 
   it "should load translations" do
@@ -37,15 +42,13 @@ describe R18n::I18n do
   end
 
   it "should load default translation" do
-    R18n::I18n.default = 'en'
-    
-    i18n = R18n::I18n.new('no_LC', DIR)
+    i18n = R18n::I18n.new('no-LC', DIR)
     i18n.one.should == 'ONE'
     i18n.two.should == 'Two'
   end
 
   it "should load sublocales for first locale" do
-    R18n::I18n.default = 'no_TR'
+    R18n::I18n.default = 'no-TR'
     
     i18n = R18n::I18n.new('ru', DIR)
     i18n.one.should == 'Один'
@@ -54,32 +57,74 @@ describe R18n::I18n do
 
   it "should return available translations" do
     i18n = R18n::I18n.new('en', DIR)
-    i18n.translations.should == {
-      'no_LC' => 'no_LC', 'ru' => 'Русский', 'en' => 'English'}
+    i18n.translations.should == { 'no-lc' => 'no-lc', 'ru' => 'Русский',
+                                  'en' => 'English' }
   end
 
   it "should return first locale with locale file" do
-    i18n = R18n::I18n.new(['no_LC', 'ru', 'en'], DIR)
-    i18n.locale.should == R18n::Locale.load('ru')
+    i18n = R18n::I18n.new(['no-LC', 'ru', 'en'], DIR)
+    i18n.locale.should == R18n::Locale.load('no-LC')
+    i18n.locale.base.should == R18n::Locale.load('ru')
   end
 
   it "should localize objects" do
-    i18n = R18n::I18n.new('ru', DIR)
+    i18n = R18n::I18n.new('ru')
     
     i18n.l(-123456789).should == '−123 456 789'
     i18n.l(-12345.67).should == '−12 345,67'
     
     time = Time.at(0).utc
-    i18n.l(time).should =~ /^Чтв, 01 янв 1970, 00:00:00 (GMT|UTC)$/
-    i18n.l(time, :time).should == '00:00'
     i18n.l(time, '%A').should == 'Четверг'
+    i18n.l(time, :month).should == 'Январь'
+    i18n.l(time, :standard).should == '01.01.1970 00:00'
+    i18n.l(time, :full).should == ' 1 января 1970 00:00'
     
     i18n.l(Date.new(0)).should == '01.01.0000'
   end
   
-  it "should loading without translations" do
+  it "should localize date for human" do
     i18n = R18n::I18n.new('ru')
-    i18n.l(Date.new(0)).should == '01.01.0000'
+    
+    i18n.l(Date.today + 2, :human).should == 'через 2 дня'
+    i18n.l(Date.today + 1, :human).should == 'завтра'
+    i18n.l(Date.today,     :human).should == 'сегодня'
+    i18n.l(Date.today - 1, :human).should == 'вчера'
+    i18n.l(Date.today - 3, :human).should == '3 дня назад'
+    
+    y2000 = Date.parse('2000-01-08')
+    i18n.l(y2000, :human, Date.parse('2000-01-01')).should == ' 8 января'
+    i18n.l(y2000, :human, Date.parse('1999-01-01')).should == ' 8 января 2000'
+  end
+  
+  it "should localize times for human" do
+    i18n = R18n::I18n.new('ru')
+    minute = 60
+    hour   = 60 * minute
+    day    = 24 * hour
+    zero   = Time.at(0).utc
+    
+    i18n.l( zero + 7 * day,     :human, zero).should == ' 8 января 00:00'
+    i18n.l( zero + 50 * hour,   :human, zero).should == 'через 2 дня 02:00'
+    i18n.l( zero + 25 * hour,   :human, zero).should == 'завтра 01:00'
+    i18n.l( zero + 70 * minute, :human, zero).should == 'через 1 час'
+    i18n.l( zero + 38 * minute, :human, zero).should == 'через 38 минут'
+    i18n.l( zero + 5,           :human, zero).should == 'сейчас'
+    i18n.l( zero - 15,          :human, zero).should == 'сейчас'
+    i18n.l( zero - minute,      :human, zero).should == '1 минуту назад'
+    i18n.l( zero - 2 * hour,    :human, zero).should == '2 часа назад'
+    i18n.l( zero - 13 * hour,   :human, zero).should == 'вчера 11:00'
+    i18n.l( zero - 50 * hour,   :human, zero).should == '3 дня назад 22:00'
+    i18n.l( zero - 9 * day,     :human, zero).should == '23 декабря 1969 00:00'
+  end
+  
+  it "should use standard formatter by default" do
+    R18n::I18n.new('ru').l(Time.at(0).utc).should == '01.01.1970 00:00'
+  end
+  
+  it "should raise error on unknown formatter" do
+    lambda {
+      R18n::I18n.new('ru').l(Time.at(0).utc, :unknown)
+    }.should raise_error(ArgumentError, /formatter/)
   end
 
 end

data/spec/locale_spec.rb

@@ -1,33 +1,38 @@
 # encoding: utf-8
-require File.join(File.dirname(__FILE__), "spec_helper")
+require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe R18n::Locale do
 
   it "should check is locale exists" do
     R18n::Locale.exists?('ru').should be_true
-    R18n::Locale.exists?('no_LC').should be_false
+    R18n::Locale.exists?('no-LC').should be_false
   end
 
   it "should load locale" do
     locale = R18n::Locale.load('ru')
-    locale['code'].should == 'ru'
-    locale['title'].should == 'Русский'
+    locale.code.should == 'ru'
+    locale.title.should == 'Русский'
+    locale.ltr?.should be_true
+  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
     
-    en = R18n::Locale.load('en')
-    en.class.should == R18n::Locale
+    eo = R18n::Locale.load('eo')
+    eo.class.should == R18n::Locale
   end
 
   it "should include locale by +include+ option" do
-    en_US = R18n::Locale.load('en_US')
+    enUS = R18n::Locale.load('en-US')
     en = R18n::Locale.load('en')
-    en_US['title'].should == 'English (US)'
-    en['title'].should == 'English'
-    en_US['week'].should == en['week']
+    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
@@ -55,12 +60,23 @@ describe R18n::Locale do
   end
 
   it "should use UnsupportedLocale if locale file isn't exists" do
-    locale = R18n::Locale.load('no_LC')
-    locale.should be_a(R18n::UnsupportedLocale)
-    locale['code'].should == 'no_LC'
-    locale['title'].should be_empty
-    locale['direction'].should == 'ltr'
-    locale.pluralize(5).should == 'n'
+    supported = R18n::Locale.load('en')
+    supported.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.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'
   end
 
   it "should format number in local traditions" do
@@ -80,14 +96,25 @@ describe R18n::Locale do
     locale.strftime(time, '%a %A').should == 'Чтв Четверг'
     locale.strftime(time, '%b %B').should == 'янв января'
     locale.strftime(time, '%H:%M%p').should == '00:00 утра'
-    
-    locale.strftime(time, :month).should == 'Январь'
-    locale.strftime(time, :datetime).should =~ /^Чтв, 01 янв 1970, 00:00:00 (GMT|UTC)$/
   end
 
   it "should delete slashed from locale for security reasons" do
     locale = R18n::Locale.load('../spec/translations/general/en')
     locale.should be_a(R18n::UnsupportedLocale)
   end
+  
+  it "should ignore code case in locales" do
+    upcase = R18n::Locale.load('RU')
+    downcase = R18n::Locale.load('ru')
+    upcase.should == downcase
+    upcase.code.should == 'ru'
+    downcase.code.should == 'ru'
+    
+    upcase = R18n::Locale.load('no-LC')
+    downcase = R18n::Locale.load('no-lc')
+    upcase.should == downcase
+    upcase.code.should == 'no-LC'
+    downcase.code.should == 'no-lc'
+  end
 
 end

data/spec/locales/cs_spec.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+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.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(101).should == 'n'
+    ru.pluralize(102).should == 'n'
+    ru.pluralize(111).should == 'n'
+  end
+end

data/spec/locales/en-us_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'locales', 'en-us')
+
+describe R18n::Locales::EnUs do
+  it "should format American English date" do
+    enUS = R18n::I18n.new('en-US')
+    enUS.l(Date.parse('2009-05-01'), :full).should ==  'May 1st, 2009'
+    enUS.l(Date.parse('2009-05-02'), :full).should ==  'May 2nd, 2009'
+    enUS.l(Date.parse('2009-05-03'), :full).should ==  'May 3rd, 2009'
+    enUS.l(Date.parse('2009-05-04'), :full).should ==  'May 4th, 2009'
+    enUS.l(Date.parse('2009-05-11'), :full).should == 'May 11th, 2009'
+    enUS.l(Date.parse('2009-05-21'), :full).should == 'May 21st, 2009'
+  end
+end

data/spec/locales/en_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'locales', 'en')
+
+describe R18n::Locales::En do
+  it "should format English date" do
+    en = R18n::I18n.new('en')
+    en.l(Date.parse('2009-05-01'), :full).should ==  '1st of May, 2009'
+    en.l(Date.parse('2009-05-02'), :full).should ==  '2nd of May, 2009'
+    en.l(Date.parse('2009-05-03'), :full).should ==  '3rd of May, 2009'
+    en.l(Date.parse('2009-05-04'), :full).should ==  '4th of May, 2009'
+    en.l(Date.parse('2009-05-11'), :full).should == '11th of May, 2009'
+    en.l(Date.parse('2009-05-21'), :full).should == '21st of May, 2009'
+  end
+end

data/spec/locales/fr_spec.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'locales', 'fr')
+
+describe R18n::Locales::Fr do
+  it "should format French date" do
+    fr = R18n::I18n.new('fr')
+    fr.l(Date.parse('2009-07-01'), :full).should ==  '1er juillet 2009'
+    fr.l(Date.parse('2009-07-02'), :full).should ==  ' 2 juillet 2009'
+  end
+end

data/spec/locales/pl_spec.rb

@@ -1,25 +1,25 @@
-require File.join(File.dirname(__FILE__), "..", "spec_helper")
-require File.join(File.dirname(__FILE__), "..", "..", "locales", "pl")
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'locales', 'pl')
 
 describe R18n::Locales::Pl do
   it "should use Polish pluralization" do
-    ru = R18n::Locale.load 'pl'
-    ru.pluralize(0).should == 0
+    pl = R18n::Locale.load 'pl'
+    pl.pluralize(0).should == 0
     
-    ru.pluralize(1).should == 1
-    ru.pluralize(21).should == 'n'
-    ru.pluralize(101).should == 'n'
+    pl.pluralize(1).should == 1
     
-    ru.pluralize(2).should == 2
-    ru.pluralize(4).should == 2
-    ru.pluralize(22).should == 2
-    ru.pluralize(102).should == 2
+    pl.pluralize(2).should == 2
+    pl.pluralize(4).should == 2
+    pl.pluralize(22).should == 2
+    pl.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(111).should == 'n'
-    ru.pluralize(112).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'
   end
 end

data/spec/locales/ru_spec.rb

@@ -1,5 +1,5 @@
-require File.join(File.dirname(__FILE__), "..", "spec_helper")
-require File.join(File.dirname(__FILE__), "..", "..", "locales", "ru")
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'locales', 'ru')
 
 describe R18n::Locales::Ru do
   it "should use Russian pluralization" do

data/spec/r18n_spec.rb

@@ -22,13 +22,17 @@ describe R18n do
                   :c => 2 }
   end
   
+  it "should convert Time to Date" do
+      R18n::Utils.to_date(Time.now).should == Date.today
+  end
+  
   it "should set untranslated format" do
-    translation = R18n::Translation.load('en', DIR)
+    i18n = R18n::I18n.new('en', DIR)
     R18n.untranslated = nil
-    translation.in.not.to_s.should be_nil
+    i18n.in.not.to_s.should be_nil
     
     R18n.untranslated = '%1 %2[%3]'
-    translation.in.not.to_s.should == 'in.not in.[not]'
+    i18n.in.not.to_s.should == 'in.not in.[not]'
   end
 
 end

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+require 'pp'
+
 require File.join(File.dirname(__FILE__), '../lib/r18n-core')
 
 DIR = Pathname(__FILE__).dirname + 'translations/general' unless defined? DIR

data/spec/translated_spec.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'lib', 'r18n-core', 'translated')
+
+describe R18n::Translated do
+  before do
+    @user_class = Class.new do
+      include R18n::Translated
+      attr_accessor :name_ru, :name_en
+    end
+    R18n.set(R18n::I18n.new('en'))
+  end
+  
+  it "should save methods map" do
+    @user_class.translation :name, :methods => { :ru => :name_ru }
+    @user_class.unlocalized_getters(:name).should == { 'ru' => 'name_ru' }
+    @user_class.unlocalized_setters(:name).should == { 'ru' => 'name_ru=' }
+  end
+  
+  it "should autodetect methods map" do
+    @user_class.translation :name
+    @user_class.unlocalized_getters(:name).should == {
+        'en' => 'name_en', 'ru' => 'name_ru' }
+    @user_class.unlocalized_setters(:name).should == {
+        'en' => 'name_en=', 'ru' => 'name_ru=' }
+  end
+  
+  it "should translate methods" do
+    @user_class.translation :name
+    user = @user_class.new
+    
+    user.name.should be_nil
+    user.name = 'John'
+    user.name.should == 'John'
+    
+    R18n.set(R18n::I18n.new('ru'))
+    user.name.should == 'John'
+    user.name = 'Джон'
+    user.name.should == 'Джон'
+  end
+  
+  it "should return TranslatedString" do
+    class ::SomeTranslatedClass
+      include R18n::Translated
+      def name_en; 'John'; end
+      translation :name
+    end
+    obj = ::SomeTranslatedClass.new
+    
+    obj.name.should be_a(R18n::TranslatedString)
+    obj.name.locale.should == R18n::Locale.load('en')
+    obj.name.path.should == 'SomeTranslatedClass#name'
+  end
+  
+  it "should search translation by locales priority" do
+    @user_class.translation :name
+    user = @user_class.new
+    
+    R18n.set(R18n::I18n.new(['no-LC', 'ru', 'en']))
+    user.name_ru = 'Иван'
+    user.name.locale.should == R18n::Locale.load('ru')
+  end
+  
+  it "should use default locale" do
+    @user_class.translation :name
+    user = @user_class.new
+    
+    R18n.set(R18n::I18n.new('no-LC'))
+    user.name_en = 'John'
+    user.name.locale.should == R18n::Locale.load('en')
+  end
+  
+  it "should use filters" do
+    @user_class.class_eval do
+      def age_en; {1 => '%1 year', 'n' => '%1 years'} end
+      translation :age, :type => 'pl', :no_params => true
+    end
+    user = @user_class.new
+    
+    user.age(20).should == '20 years'
+  end
+  
+  it "should send params to method if user want it" do
+    @user_class.class_eval do
+      def no_params_en(*params) params.join(' '); end
+      def params_en(*params)    params.join(' '); end
+      translations [:no_params, {:no_params => true}], :params
+    end
+    user = @user_class.new
+    
+    user.no_params(1, 2).should == ''
+    user.params(1, 2).should == '1 2'
+  end
+  
+  it "should return Untranslated when can't find translation" do
+    class ::SomeUntranslatedClass
+      include R18n::Translated
+      
+      translation :no
+    end
+    obj = ::SomeUntranslatedClass.new
+    
+    obj.no.should be_a(R18n::Untranslated)
+    obj.no.translated_path.should == 'SomeUntranslatedClass#'
+    obj.no.untranslated_path.should == 'no'
+  end
+  
+end