lolita-i18n 0.5.6 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6dbd5a79aef20c66bcdc9f27d4d85fb01f8720a7
-  data.tar.gz: 8a3eba1f6b433de69dd7c2b25a147d6ab28ac78e
+  metadata.gz: f500d667490e09464baaa16c0e26b6583c375064
+  data.tar.gz: 5a4fcd9e2cff8e7d718fb649ac27940da5ac7517
 SHA512:
-  metadata.gz: f1b3bed0c85e87f7626aa02c0b0fd0beab631319aef7d15ab86c9bb3d3d8dce195a3fe7ab9ae3f08e1d3a004d46076acd2e27ca8a9401e8e0906fc34fdee164a
-  data.tar.gz: 06c40619addc9ccaff3f9703c1b30f3c97fb5d7cdaa9cd60a5df5b294d5fb2591de85edd360555876885e4a6759e8886bbab512c2b2ea7373357e5427aeb5731
+  metadata.gz: a223a81628cde28509ba332550755f55a2be4c7168a20c779508af178d68cb3ac5880e2426ee941b14c38ad4560567f6c386c2be6273c668178af3d7dc56db19
+  data.tar.gz: ae6b940f0014e20deaa3637229da21d56f9e9dde966083868001a3df40bd3244119710639a18ad9bd010c319b11bdd93e32b25ab8b20d6b6f711493f7f8f1681

data/Gemfile

@@ -5,12 +5,13 @@ gemspec
 group :test do
   gem 'byebug'
   gem 'rails', '~> 3.2.0'
+  gem 'lolita', '~> 4.0'
   gem 'simplecov', '~> 0.7.1'
   gem 'bson_ext', '~> 1.10.1'
   gem 'mongoid', '~> 2.7.1'
   gem 'rspec-rails', '~> 2.14'
   gem 'capybara', '~> 2.1'
-  gem 'selenium-webdriver', '~> 2.41.0'
+  gem 'selenium-webdriver'
   gem 'sass', '~> 3.2.3'
   gem 'coffee-script', '~>2.2.0'
   gem 'axlsx', '~> 2.0.1'

data/LICENSE.txt

@@ -1,20 +1,20 @@
-Copyright (c) 2011 ITHouse (Latvia) and Arturs Meisters
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright (c) 2011 ITHouse (Latvia) and Arturs Meisters
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/config/locales/en.yml

@@ -4,6 +4,7 @@ en:
   ru: Russian
   de: German
   sv: Swedish
+  sv_SE: Swedish
   lt: Lithuanian
   ee: Estonian
   lolita-i18n:

data/config/locales/lv.yml

@@ -4,6 +4,7 @@ lv:
   ru: Krievu
   de: Vācu
   sv: Zviedru
+  sv_SE: Zviedru
   lt: Lietuviešu
   ee: Igauņu
   lolita-i18n:

data/lib/lolita-i18n/version.rb

@@ -1,7 +1,7 @@
 module Lolita
   module I18n
     class Version
-      VERSION = "0.5.6"
+      VERSION = "0.5.7"
 
       def self.to_s
         VERSION

data/lolita-i18n.gemspec

@@ -18,13 +18,13 @@ Gem::Specification.new do |s|
   ]
   s.licenses = ["MIT"]
 
-  s.add_runtime_dependency(%q<lolita>, ["~> 3.2"])
+  s.add_runtime_dependency(%q<lolita>, [">= 3.2"])
   s.add_runtime_dependency(%q<i18n>, ["~> 0.6.1"])
-  s.add_runtime_dependency(%q<hiredis>, ["~> 0.4.5"])
-  s.add_runtime_dependency(%q<redis>, ["~> 3.0.3"])
-  s.add_runtime_dependency(%q<yajl-ruby>,["~> 1.1.0"])
-  s.add_runtime_dependency(%q<unicode_utils>,["~> 1.4.0"])
-  s.add_runtime_dependency(%q<axlsx>,["~> 2.0.1"])
+  s.add_runtime_dependency(%q<hiredis>, ["~> 0.4"])
+  s.add_runtime_dependency(%q<redis>, ["~> 3.0"])
+  s.add_runtime_dependency(%q<yajl-ruby>,["~> 1.1"])
+  s.add_runtime_dependency(%q<unicode_utils>,["~> 1.4"])
+  s.add_runtime_dependency(%q<axlsx>,["~> 2.0"])
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]

data/spec/controllers/lolita/i18n_controller_spec.rb

@@ -4,61 +4,61 @@ describe Lolita::I18nController do
   
   describe "GET index" do 
     it "should authorize resource" do
-      controller.authorization_proxy.should_receive(:authorize!).with(:read,controller.resource_class)
+      expect(controller.authorization_proxy).to receive(:authorize!).with(:read,controller.resource_class)
       get :index
     end
 
     it "should assign all translations to variable" do 
       get :index
-      assigns[:translations].should be_kind_of(Hash)
+      expect(assigns[:translations]).to be_kind_of(Hash)
     end
 
     it "should sort translations when params[:sort] is equal to 1" do 
       i18n_request = double("i18n_request")
-      i18n_request.stub(:translations)
+      allow(i18n_request).to receive(:translations)
       controller.stub(:i18n_request => i18n_request)
-      i18n_request.should_not_receive(:sort_translations)
+      expect(i18n_request).not_to receive(:sort_translations)
       get :index
       i18n_request = double("i18n_request2")
-      i18n_request.stub(:translations)
+      allow(i18n_request).to receive(:translations)
       controller.stub(:i18n_request => i18n_request)
-      i18n_request.should_receive(:sort_translations)
+      expect(i18n_request).to receive(:sort_translations)
       get :index, :sort => 1
     end
   end
 
   describe "PUT update" do 
     it "should authorize resource for update" do 
-      controller.authorization_proxy.should_receive(:authorize!).with(:update,controller.resource_class)
+      expect(controller.authorization_proxy).to receive(:authorize!).with(:update,controller.resource_class)
       put :update, :id => "key", :translation => "translation", :format => :json
     end
 
     it "should create notice when save is successful" do 
-      controller.stub(:i18n_request => stub(:update_key => true))
-      controller.should_receive(:notice).with(kind_of(String))
+      controller.stub(:i18n_request => double(:update_key => true))
+      expect(controller).to receive(:notice).with(kind_of(String))
       put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
     end
 
     it "should create error when save is unsuccessful" do 
-      controller.stub(:i18n_request => stub(:update_key => false))
-      controller.should_receive(:error).with(kind_of(String))
+      controller.stub(:i18n_request => double(:update_key => false))
+      expect(controller).to receive(:error).with(kind_of(String))
       put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
     end
 
     it "should render error when Lolita::I18n::Exceptions::MissingInterpolationArgument is raised" do 
       i18n_request = double("request")
-      i18n_request.stub(:update_key).and_raise(Lolita::I18n::Exceptions::MissingInterpolationArgument.new(["%{count}"]))
+      allow(i18n_request).to receive(:update_key).and_raise(Lolita::I18n::Exceptions::MissingInterpolationArgument.new(["%{count}"]))
       controller.stub(:i18n_request => i18n_request)
       put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
-      response.body.should eq(%q{{"error":"Translation should contain all these variables %{count}"}})
+      expect(response.body).to eq(%q{{"error":"Translation should contain all these variables %{count}"}})
     end
 
     it "should render error when any other excption happens" do 
       i18n_request = double("request")
-      i18n_request.stub(:update_key).and_raise(ArgumentError.new)
+      allow(i18n_request).to receive(:update_key).and_raise(ArgumentError.new)
       controller.stub(:i18n_request => i18n_request)
       put :update, :id => Base64.encode64("lv.title"),:translation => "Tulkots virsraksts", :format => :json
-      response.body.should eq(%q{{"error":"Key is not saved. Some error accured."}})
+      expect(response.body).to eq(%q{{"error":"Key is not saved. Some error accured."}})
     end 
   end
 end

data/spec/features/translating_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe "Translating process" do 
    def translate_key(key)
-    page.should have_selector("textarea[name='#{key}']")
+    expect(page).to have_selector("textarea[name='#{key}']")
     fill_in(key, :with => "translation for #{key}")
     page.execute_script(%Q{$("textarea[name='#{key}']").blur()})
     page.execute_script(%Q{window.location.href='#'})
     page.check("show_untranslated")
-    page.find_field(key).value.should == "translation for #{key}"
+    expect(page.find_field(key).value).to eq("translation for #{key}")
   end
 
   before(:each) do 

data/spec/features/translation_list_spec.rb

@@ -7,8 +7,8 @@ describe "Viewing all translations", :redis => true, :js => true do
 
   it "User see translations in default language and same translation in other language" do 
     within(".i18n-box .list>table>thead") do 
-      page.should have_selector("th", :text => "English")
-      page.should have_selector("th>select option[selected]", :text => "Latvian")
+      expect(page).to have_selector("th", :text => "English")
+      expect(page).to have_selector("th>select option[selected]", :text => "Latvian")
     end
   end
 
@@ -16,21 +16,21 @@ describe "Viewing all translations", :redis => true, :js => true do
     within(".i18n-box .list>table>thead") do 
       page.select("Russian", :from => "active_locale")
     end
-    page.should have_selector("th select option[selected]", :text => "Russian")
+    expect(page).to have_selector("th select option[selected]", :text => "Russian")
   end
 
   it "User can view only untranslated" do 
-    page.should have_selector("textarea", :text => "Virsraksts")
+    expect(page).to have_selector("textarea", :text => "Virsraksts")
     page.check("show_untranslated")
-    page.should have_selector("textarea", :text => "Other")
-    page.should_not have_selector("textarea", :text => "Virsraksts")
+    expect(page).to have_selector("textarea", :text => "Other")
+    expect(page).not_to have_selector("textarea", :text => "Virsraksts")
   end
 
   it "User can sort original translation in ascending order" do 
     last_trans = page.evaluate_script("$('textarea:last').val()");
-    last_trans.should_not eq("zzzz")
+    expect(last_trans).not_to eq("zzzz")
     click_link("translation_sort_link")
     new_last_trans = page.evaluate_script("$('textarea:last').val()");
-    new_last_trans.should eq("zzzz")
+    expect(new_last_trans).to eq("zzzz")
   end
 end

data/spec/helpers/lolita/i18n_helper_spec.rb

@@ -5,55 +5,56 @@ describe Lolita::I18nHelper, :rails => true do
     good_locale_options = [
       ["Choose other language",nil],
       ["Latvian",:lv],
-      ["Russian",:ru]
+      ["Russian",:ru],
+      ["Swedish",:sv_SE]
     ]
-    helper.locale_options.should eq(good_locale_options)
+    expect(helper.locale_options).to eq(good_locale_options)
   end
 
   it "#is_untranslated?" do
-    helper.is_untranslated?("").should be_true
-    helper.is_untranslated?("text").should be_false
-    helper.is_untranslated?([]).should be_true
-    helper.is_untranslated?({}).should be_true
+    expect(helper.is_untranslated?("")).to be_truthy
+    expect(helper.is_untranslated?("text")).to be_falsey
+    expect(helper.is_untranslated?([])).to be_truthy
+    expect(helper.is_untranslated?({})).to be_truthy
   end
 
   it "translation is visible when value is not blank and params does not say to show only untranslated values" do 
-    helper.translation_visible?("", nil).should be_true
-    helper.translation_visible?("text", nil).should be_true
-    helper.translation_visible?([], nil).should be_true
-    helper.translation_visible?({}, nil).should be_true
+    expect(helper.translation_visible?("", nil)).to be_truthy
+    expect(helper.translation_visible?("text", nil)).to be_truthy
+    expect(helper.translation_visible?([], nil)).to be_truthy
+    expect(helper.translation_visible?({}, nil)).to be_truthy
 
     helper.params[:show_untranslated] = true
-    helper.translation_visible?("", nil).should be_true
-    helper.translation_visible?("text", nil).should be_false
-    helper.translation_visible?([], nil).should be_true
-    helper.translation_visible?({}, nil).should be_true
+    expect(helper.translation_visible?("", nil)).to be_truthy
+    expect(helper.translation_visible?("text", nil)).to be_falsey
+    expect(helper.translation_visible?([], nil)).to be_truthy
+    expect(helper.translation_visible?({}, nil)).to be_truthy
   end
 
   describe "#any_translation_visible?" do 
     it "should detect if any translation from array is visible" do 
-      helper.any_translation_visible?([2,1], nil).should be_true
-      helper.any_translation_visible?([], nil).should be_true
+      expect(helper.any_translation_visible?([2,1], nil)).to be_truthy
+      expect(helper.any_translation_visible?([], nil)).to be_truthy
 
       helper.params[:show_untranslated] = true
-      helper.any_translation_visible?([], nil).should be_true
-      helper.any_translation_visible?(["",1], nil).should be_true
-      helper.any_translation_visible?(["a","b"], nil).should be_false
+      expect(helper.any_translation_visible?([], nil)).to be_truthy
+      expect(helper.any_translation_visible?(["",1], nil)).to be_truthy
+      expect(helper.any_translation_visible?(["a","b"], nil)).to be_falsey
     end
 
 
     it "should detect if any translation from hash is visible" do 
-      helper.any_translation_visible?({:a => "1",:b => "2" }, nil).should be_true
-      helper.any_translation_visible?([], nil).should be_true
+      expect(helper.any_translation_visible?({:a => "1",:b => "2" }, nil)).to be_truthy
+      expect(helper.any_translation_visible?([], nil)).to be_truthy
 
       helper.params[:show_untranslated] = true
-      helper.any_translation_visible?({}, nil).should be_true
-      helper.any_translation_visible?({:a => "1",:b => "2" }, nil).should be_false
-      helper.any_translation_visible?({:a => "1",:b => "" }, nil).should be_true
+      expect(helper.any_translation_visible?({}, nil)).to be_truthy
+      expect(helper.any_translation_visible?({:a => "1",:b => "2" }, nil)).to be_falsey
+      expect(helper.any_translation_visible?({:a => "1",:b => "" }, nil)).to be_truthy
     end
 
     it "should call #translation_visible? for any other value" do 
-      helper.should_receive(:translation_visible?).with("text", '/url')
+      expect(helper).to receive(:translation_visible?).with("text", '/url')
       helper.any_translation_visible?("text", '/url')
     end
   end
@@ -65,12 +66,12 @@ describe Lolita::I18nHelper, :rails => true do
       end
     end
     it "should create link with sort in it when params does not include :sort" do 
-      helper.sort_link.should match(/sort=1/)
+      expect(helper.sort_link).to match(/sort=1/)
     end
 
     it "should create link witho sort in it when params include :sort"  do 
       helper.params[:sort] = "1"
-      helper.sort_link.should_not match(/sort=1/)
+      expect(helper.sort_link).not_to match(/sort=1/)
     end
   end
 

data/spec/lolita-i18n/configuration_spec.rb

@@ -5,132 +5,132 @@ describe Lolita::I18n::Configuration do
   let(:redis){ double("redis", :ping => true, client: double(disconnect: true, reconnect: true)) }
 
   it "should load rails if Rails is defined" do
-    Lolita.stub(:rails3?).and_return(true)
-    subject.should_receive(:require).with('lolita-i18n/rails')
+    allow(Lolita).to receive(:rails3?).and_return(true)
+    expect(subject).to receive(:require).with('lolita-i18n/rails')
     subject.load_rails!
   end
 
   it "should allow to assign store with Hash as connection options" do
-    Redis.should_receive(:new).with({:key => "value"}).and_return(redis)
+    expect(Redis).to receive(:new).with({:key => "value"}).and_return(redis)
     subject.store = {:key => "value"}
   end
 
   it "should allow to assign store as store itself" do
     subject.store = redis
-    subject.store.should eq(redis)
+    expect(subject.store).to eq(redis)
   end
 
   it "should return assigned store" do
     subject.store = redis
-    subject.store.should eq(redis)
+    expect(subject.store).to eq(redis)
   end
 
   it "should return new Redis connection and warn when no store is assigned"  do
-    Redis.should_receive(:new).and_return(redis)
-    subject.should_receive(:warn).with("Lolita::I18n No store specified. See Lolita::I18n")
-    subject.store.should eq(redis)
+    expect(Redis).to receive(:new).and_return(redis)
+    expect(subject).to receive(:warn).with("Lolita::I18n No store specified. See Lolita::I18n")
+    expect(subject.store).to eq(redis)
   end
 
   it "should lazy create and return backend" do
-    Redis.should_receive(:new).and_return(redis)
-    ::I18n::Backend::KeyValue.should_receive(:new).with(redis)
+    expect(Redis).to receive(:new).and_return(redis)
+    expect(::I18n::Backend::KeyValue).to receive(:new).with(redis)
     subject.backend
   end
 
   it "should load translations" do
     yaml_backend = double("yaml_backend")
     subject.yaml_backend = yaml_backend
-    yaml_backend.should_receive(:load_translations)
+    expect(yaml_backend).to receive(:load_translations)
     subject.load_translations
   end
 
   it "should initialize chain" do
     subject.yaml_backend = double("yaml backend")
-    Redis.stub(:new).and_return(redis)
-    ::I18n::Backend::Chain.should_receive(:new).with(subject.backend,subject.yaml_backend)
+    allow(Redis).to receive(:new).and_return(redis)
+    expect(::I18n::Backend::Chain).to receive(:new).with(subject.backend,subject.yaml_backend)
     subject.initialize_chain
-    Redis.unstub(:new)
+    allow(Redis).to receive(:new).and_call_original
   end
 
   describe "#connect" do
-    before(:each){ Redis.stub(:new).and_return(redis) }
-    after(:each){ Redis.unstub(:new) }
+    before(:each){ allow(Redis).to receive(:new).and_return(redis) }
+    after(:each){ allow(Redis).to receive(:new).and_call_original }
 
     it "should call reconnect if not connected" do
-      subject.should_receive(:initialize_chain).once
+      expect(subject).to receive(:initialize_chain).once
       subject.connect
       subject.connect
     end
 
     it "should return true when success" do
-      subject.connect.should be_true
+      expect(subject.connect).to be_truthy
     end
 
     it "should return not be true when fail" do
-      Redis.stub(:new).and_raise(Errno::ECONNREFUSED)
-      subject.connect.should_not be_true
+      allow(Redis).to receive(:new).and_raise(Errno::ECONNREFUSED)
+      expect(subject.connect).not_to be_truthy
     end
   end
 
   describe "#reconnect" do
     it "should call init if not initialized jet" do
-      subject.should_receive(:init).once
+      expect(subject).to receive(:init).once
       subject.reconnect
     end
 
     it "should not call init if already initialized" do
       subject.reconnect
-      subject.should_not_receive(:init)
+      expect(subject).not_to receive(:init)
       subject.reconnect
     end
 
     it "should return true when success" do
-      subject.reconnect.should be_true
+      expect(subject.reconnect).to be_truthy
     end
 
     it "should return false when fail" do
-      Redis.stub(:new).and_raise(Errno::ECONNREFUSED)
-      subject.reconnect.should_not be_true
-      Redis.unstub(:new)
+      allow(Redis).to receive(:new).and_raise(Errno::ECONNREFUSED)
+      expect(subject.reconnect).not_to be_truthy
+      allow(Redis).to receive(:new).and_call_original
     end
 
     it "should initialize chain" do
-      subject.should_receive(:initialize_chain).twice
+      expect(subject).to receive(:initialize_chain).twice
       subject.reconnect
       subject.reconnect
     end
 
     it "should disconnect" do
-      subject.should_receive(:disconnect)
+      expect(subject).to receive(:disconnect)
       subject.reconnect
     end
   end
 
   describe "#disconnect" do
     it "should disconnect if connected" do
-      subject.store.client.should_receive(:disconnect).twice
+      expect(subject.store.client).to receive(:disconnect).twice
       subject.connect
       subject.disconnect
     end
 
     it "should not disconnect if not connected"do
-      subject.store.client.should_not_receive(:disconnect)
+      expect(subject.store.client).not_to receive(:disconnect)
       subject.disconnect
     end
   end
 
   describe "#init" do
     it "should call all propper methods" do
-      subject.should_receive(:include_modules)
-      subject.should_receive(:set_yaml_backend)
-      subject.should_receive(:connect)
+      expect(subject).to receive(:include_modules)
+      expect(subject).to receive(:set_yaml_backend)
+      expect(subject).to receive(:connect)
       subject.init
     end
 
     it "should run only once" do
-      subject.should_receive(:include_modules).once
-      subject.should_receive(:set_yaml_backend).once
-      subject.should_receive(:connect).once
+      expect(subject).to receive(:include_modules).once
+      expect(subject).to receive(:set_yaml_backend).once
+      expect(subject).to receive(:connect).once
       subject.init
       subject.init
     end
@@ -139,9 +139,9 @@ describe Lolita::I18n::Configuration do
   describe "#include_modules" do
     it "include module in ::I18n::Backend::Simple" do
       subject.include_modules
-      ::I18n::Backend::Simple.ancestors.should include(::I18n::Backend::Flatten)
-      ::I18n::Backend::Simple.ancestors.should include(::I18n::Backend::Pluralization)
-      ::I18n::Backend::Simple.ancestors.should include(::I18n::Backend::InterpolationCompiler)
+      expect(::I18n::Backend::Simple.ancestors).to include(::I18n::Backend::Flatten)
+      expect(::I18n::Backend::Simple.ancestors).to include(::I18n::Backend::Pluralization)
+      expect(::I18n::Backend::Simple.ancestors).to include(::I18n::Backend::InterpolationCompiler)
     end
   end
 

data/spec/lolita-i18n/exceptions_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Lolita::I18n::Exceptions::MissingInterpolationArgument do 
   it "create new StandartError with custom message" do 
     error = Lolita::I18n::Exceptions::MissingInterpolationArgument.new(["arg1","arg2"])
-    error.message.should eq("Translation should contain all these variables arg1, arg2")
+    expect(error.message).to eq("Translation should contain all these variables arg1, arg2")
   end
 end
 
 describe Lolita::I18n::Exceptions::TranslationDoesNotMatch do 
   it "should cretae new ArgumentError with custom message" do 
     error = Lolita::I18n::Exceptions::TranslationDoesNotMatch.new("translation", "original")
-    error.message.should eq("Translation translation does not match original")
+    expect(error.message).to eq("Translation translation does not match original")
   end
 end

data/spec/lolita-i18n/request_spec.rb

@@ -6,53 +6,53 @@ describe Lolita::I18n::Request do
     let(:validator){Lolita::I18n::Request::Validator.new}
 
     it "should validate string and return error when original and given values interpolations doesn't match" do
-      ::I18n.stub(:t).and_return("original text")
+      allow(::I18n).to receive(:t).and_return("original text")
       expect{validator.validate("text_key","text")}.not_to raise_error
 
-      ::I18n.stub(:t).and_return("text with %{interpolation}")
+      allow(::I18n).to receive(:t).and_return("text with %{interpolation}")
       expect{
         validator.validate("text_key","text")
       }.to raise_error(Lolita::I18n::Exceptions::MissingInterpolationArgument)
     end
 
     it "should validate array's each value as string" do 
-      ::I18n.stub(:t).and_return(["a","b","c"])
+      allow(::I18n).to receive(:t).and_return(["a","b","c"])
       expect{validator.validate("array_key",["1","2","3"])}.not_to raise_error
 
-      ::I18n.stub(:t).and_return(["a","%{b}","c"])
+      allow(::I18n).to receive(:t).and_return(["a","%{b}","c"])
       expect{
         validator.validate("array_key",["1","2","3"])
       }.to raise_error(Lolita::I18n::Exceptions::MissingInterpolationArgument,"Translation should contain all these variables %{b}")
     end
 
     it "should validate hash's each value as string" do 
-      ::I18n.stub(:t).and_return({:a => "1", :b => "2"})
+      allow(::I18n).to receive(:t).and_return({:a => "1", :b => "2"})
       expect{validator.validate("array_key",{"a" => "a", "b" => "b"})}.not_to raise_error
 
-      ::I18n.stub(:t).and_return({:a => "1", :b => "2 %{count}"})
+      allow(::I18n).to receive(:t).and_return({:a => "1", :b => "2 %{count}"})
       expect{
         validator.validate("array_key",{"a" => "a", "b" => "b"})
       }.to raise_error(Lolita::I18n::Exceptions::MissingInterpolationArgument)
     end
 
     it "should raise error when translation is Array but original is not or sizes does not match" do 
-      ::I18n.stub(:t).and_return("")
+      allow(::I18n).to receive(:t).and_return("")
       expect{
         validator.validate("key",[1,2])
       }.to raise_error(Lolita::I18n::Exceptions::TranslationDoesNotMatch)
 
-      ::I18n.stub(:t).and_return([1,2])
+      allow(::I18n).to receive(:t).and_return([1,2])
       expect{
         validator.validate("key",[2])
       }
     end
 
     it "should raise error when translation is Hash but original is not or keys does not match " do 
-      ::I18n.stub(:t).and_return("")
+      allow(::I18n).to receive(:t).and_return("")
       expect{
         validator.validate("key",{"a" => 1})
       }.to raise_error(Lolita::I18n::Exceptions::TranslationDoesNotMatch)
-      ::I18n.stub(:t).and_return({:a => 2, :b => 3})
+      allow(::I18n).to receive(:t).and_return({:a => 2, :b => 3})
       expect{
         validator.validate("key",{"a" => 1})
       }
@@ -71,30 +71,30 @@ describe Lolita::I18n::Request do
     end
 
     it "should return parsed value" do 
-      I18n.stub(:t).and_return("original_value")
+      allow(I18n).to receive(:t).and_return("original_value")
       t = klass.new("key","value")
-      t.value.should eq("value")
+      expect(t.value).to eq("value")
     end
 
     it "should return locale for key" do 
       t = klass.new("lv.key","value")
-      t.locale.should eq(:lv)
+      expect(t.locale).to eq(:lv)
     end
 
     it "should return key" do 
       t = klass.new("lv.key","value")
-      t.key.should eq("key")
+      expect(t.key).to eq("key")
     end
 
     it "should return array for store with locale, key => value and configuration hash" do 
       t = klass.new("lv.my.key","value")
-      t.for_store.should eq([:lv,{"my.key" => "value"}, {:escape => false}])
+      expect(t.for_store).to eq([:lv,{"my.key" => "value"}, {:escape => false}])
     end
 
     it "should return original translation of given key" do 
-      ::I18n.stub(:t).with(kind_of(String), kind_of(Hash)).and_return("original")
+      allow(::I18n).to receive(:t).with(kind_of(String), kind_of(Hash)).and_return("original")
       t = klass.new("ru.my.key","value")
-      t.original.should eq("original")
+      expect(t.original).to eq("original")
     end
   end
 
@@ -106,7 +106,7 @@ describe Lolita::I18n::Request do
 
     let(:klass){Lolita::I18n::Request::Translations}
     let(:translations) {
-      ::I18n.stub(:t) do |*args|
+      allow(::I18n).to receive(:t) do |*args|
         if args[1] && args[1][:locale] == :en
           if args[0] == :arr
             [1,2] 
@@ -132,24 +132,24 @@ describe Lolita::I18n::Request do
 
     it "should detect if value is final and should't be flattened any more" do
       t = klass.new({})
-      t.final_value?(1).should be_true
-      t.final_value?([]).should be_true
-      t.final_value?({:other => "other", :one => "one"}).should be_true
-      t.final_value?({:other => "other"}).should be_false
-      t.final_value?({:other => [], :one => 1}).should be_false
-      t.final_value?({:other => {}, :one => 1}).should be_false
+      expect(t.final_value?(1)).to be_truthy
+      expect(t.final_value?([])).to be_truthy
+      expect(t.final_value?({:other => "other", :one => "one"})).to be_truthy
+      expect(t.final_value?({:other => "other"})).to be_falsey
+      expect(t.final_value?({:other => [], :one => 1})).to be_falsey
+      expect(t.final_value?({:other => {}, :one => 1})).to be_falsey
     end
 
     it "should return default translation value for different original values" do 
       t = klass.new({})
-      ::I18n.stub(:t).and_return([])
-      t.translation_value("key",[1,2],"ru").should eq([])
-      ::I18n.stub(:t).and_return({})
-      t.translation_value("key",{:a=>1},"ru").should eq({})
-      ::I18n.stub(:t).and_return("translation")
-      t.translation_value("key","value","ru").should eq("translation")
-      ::I18n.stub(:t).and_return([1,2])
-      t.translation_value("key",[2,3],"ru").should eq([1,2])
+      allow(::I18n).to receive(:t).and_return([])
+      expect(t.translation_value("key",[1,2],"ru")).to eq([])
+      allow(::I18n).to receive(:t).and_return({})
+      expect(t.translation_value("key",{:a=>1},"ru")).to eq({})
+      allow(::I18n).to receive(:t).and_return("translation")
+      expect(t.translation_value("key","value","ru")).to eq("translation")
+      allow(::I18n).to receive(:t).and_return([1,2])
+      expect(t.translation_value("key",[2,3],"ru")).to eq([1,2])
     end
 
     it "should flatten keys until final value is found" do 
@@ -164,7 +164,7 @@ describe Lolita::I18n::Request do
         [:inter, {}, {:one => "one", :other => "other"}],
         [:"hsh.key","-no-translation-", "value"]
       ]
-      result.should eq(valid_results)
+      expect(result).to eq(valid_results)
     end 
 
     it "should normalize for locale" do
@@ -175,11 +175,11 @@ describe Lolita::I18n::Request do
         :inter => {:translation => {}, :original_translation => {:one => "one", :other => "other"}, :url => nil},
         :"hsh.key" => {:translation => "-no-translation-", :original_translation => "value", :url => nil}
       }
-      t.normalized(:lv).should eq(valid_results)
+      expect(t.normalized(:lv)).to eq(valid_results)
     end
 
     it "should normalize for locale end retur registerd URL" do
-      Redis.any_instance.stub(:[]).and_return '/kekss'
+      allow_any_instance_of(Redis).to receive(:[]).and_return '/kekss'
       t = klass.new(translations)
       valid_results = {
         :arr => {:translation => [], :original_translation => [1,2], :url => '/kekss'},
@@ -187,7 +187,7 @@ describe Lolita::I18n::Request do
         :inter => {:translation => {}, :original_translation => {:one => "one", :other => "other"}, :url => '/kekss'},
         :"hsh.key" => {:translation => "-no-translation-", :original_translation => "value", :url => '/kekss'}
       }
-      t.normalized(:lv).should eq(valid_results)
+      expect(t.normalized(:lv)).to eq(valid_results)
     end
   end
 
@@ -196,15 +196,15 @@ describe Lolita::I18n::Request do
   it "should create new request with params" do 
     expect{
       request = request_klass.new({:a => 1})
-      request.params.should eq({:a => 1})
+      expect(request.params).to eq({:a => 1})
     }.not_to raise_error
   end
 
   it "should return translations" do 
     r = request_klass.new({})
-    Lolita.i18n.should_receive(:load_translations).and_return(true)
-    Lolita.i18n.stub(:yaml_backend).and_return(stub(:translations => {:en => {}}))
-    Lolita::I18n::Request::Translations.any_instance.should_receive(:normalized).once
+    expect(Lolita.i18n).to receive(:load_translations).and_return(true)
+    allow(Lolita.i18n).to receive(:yaml_backend).and_return(double(:translations => {:en => {}}))
+    expect_any_instance_of(Lolita::I18n::Request::Translations).to receive(:normalized).once
     r.translations(:en)
   end
 
@@ -228,21 +228,21 @@ describe Lolita::I18n::Request do
       [:"key4", {:original_translation => true}], 
       [:"key9", {:original_translation => "ZZZ"}]
     ]
-    r.sort_translations(unsorted_translations).should eq(sorted_translations)
+    expect(r.sort_translations(unsorted_translations)).to eq(sorted_translations)
   end
 
   it "should update key" do 
     r = request_klass.new({:translation => "translation", :id => Base64.encode64("ru.key")})
-    ::I18n.stub(:t).and_return("original")
+    allow(::I18n).to receive(:t).and_return("original")
     backend = double("backend")
     Lolita.i18n.stub(:backend => backend)
-    backend.should_receive(:store_translations).with(:"ru", { "key" => "translation" }, :escape => false).and_return(true)
+    expect(backend).to receive(:store_translations).with(:"ru", { "key" => "translation" }, :escape => false).and_return(true)
     r.update_key
   end
 
   it "should have validator" do 
     r = request_klass.new({})
-    r.validator.should be_a_kind_of(Lolita::I18n::Request::Validator)
+    expect(r.validator).to be_a_kind_of(Lolita::I18n::Request::Validator)
   end
 
  

data/spec/lolita-i18n/version_spec.rb

@@ -3,6 +3,6 @@ require 'spec_helper'
 
 describe Lolita::I18n::Version do 
   it "should return current version of gem" do 
-    Lolita::I18n::Version.to_s.should match(/\d+\.\d+\.\d+/)
+    expect(Lolita::I18n::Version.to_s).to match(/\d+\.\d+\.\d+/)
   end
 end

data/spec/lolita_i18n_spec.rb

@@ -4,18 +4,18 @@ describe Lolita::I18n do
   describe "loaded" do 
     
     it "should check Redis connection after Lolita.setup" do 
-      Lolita.i18n.should_receive(:init)
+      expect(Lolita.i18n).to receive(:init)
       Lolita.setup{}
     end
 
     it "should add #i18n to Lolita configuration" do 
-      Lolita.configuration.should respond_to(:i18n)
+      expect(Lolita.configuration).to respond_to(:i18n)
     end
 
     it "should have Request,Configuration,Exceptions constants in module" do 
-      Lolita::I18n::Request.should be_kind_of(Class)
-      Lolita::I18n::Configuration.should be_kind_of(Class)
-      Lolita::I18n::Exceptions.should be_kind_of(Module)
+      expect(Lolita::I18n::Request).to be_kind_of(Class)
+      expect(Lolita::I18n::Configuration).to be_kind_of(Class)
+      expect(Lolita::I18n::Exceptions).to be_kind_of(Module)
     end
   end
 end

data/spec/routing/routes_spec.rb

@@ -2,10 +2,10 @@ require "spec_helper"
 
 describe "Lolita I18n routes", :rails => true do 
   it "has route for update with key" do 
-    {:put => "/lolita/i18n/my_id"}.should route_to(:controller => "lolita/i18n", :action => "update", :id => "my_id")
+    expect({:put => "/lolita/i18n/my_id"}).to route_to(:controller => "lolita/i18n", :action => "update", :id => "my_id")
   end
 
   it "has route for list of all translations" do 
-    {:get => "/lolita/i18n"}.should route_to(:controller => "lolita/i18n", :action => "index")
+    expect({:get => "/lolita/i18n"}).to route_to(:controller => "lolita/i18n", :action => "index")
   end
 end 

data/spec/spec_helper.rb

@@ -29,4 +29,15 @@ RSpec.configure do |config|
   config.before(:each, :redis) do
     Lolita.i18n.store.flushdb
   end
+
+  # rspec-rails 3 will no longer automatically infer an example group's spec type
+  # from the file location. You can explicitly opt-in to the feature using this
+  # config option.
+  # To explicitly tag specs without using automatic inference, set the `:type`
+  # metadata manually:
+  #
+  #     describe ThingsController, :type => :controller do
+  #       # Equivalent to being in spec/controllers
+  #     end
+  config.infer_spec_type_from_file_location!
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lolita-i18n
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.5.7
 platform: ruby
 authors:
 - ITHouse (Latvia)
@@ -10,20 +10,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-23 00:00:00.000000000 Z
+date: 2015-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lolita
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
@@ -46,70 +46,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.3
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.3
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: unicode_utils
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: axlsx
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: '2.0'
 description: Lolita plugin, that enables .yml files management from administrative
   interface. Also faster access to translations, that DB store
 email: support@ithouse.lv
@@ -195,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Lolita plugin, that enables .yml management
@@ -225,3 +225,4 @@ test_files:
 - spec/test_app/config/mongoid.yml
 - spec/test_app/config/routes.rb
 - spec/test_app/log/.gitkeep
+has_rdoc: