localeapp 0.9.3 → 1.0.0

data/features/update.feature

@@ -2,37 +2,37 @@ Feature: Getting new translations
 
   Scenario: Running update
     In order to receive the translations that have been updated since the last check
-    When I have a valid project on localeapp.com with api key "MYAPIKEY"
-    And an initializer file
-    And the timestamp is 2 months old
-    And new translations for the api key "MYAPIKEY" since last fetch with time "60" seconds later
-    And a directory named "config/locales"
+    Given I have a valid project on localeapp.com with api key "MYAPIKEY"
+      And an initializer file
+      And the timestamp is 2 months old
+      And new translations for the api key "MYAPIKEY" since last fetch with time "60" seconds later
+      And a directory named "config/locales"
     When I run `localeapp update`
     Then translations should be fetched since last fetch only
-    And help should not be displayed
-    And a file named "config/locales/en.yml" should exist
-    # check the content here
-    # and the localeapp.yml file
+      And help should not be displayed
+      And a file named "config/locales/en.yml" should exist
+      # check the content here
+      # and the localeapp.yml file
 
   Scenario: Running update with no initializer file, passing the key on the command line
     In order to receive the translations that have been updated since the last check
-    When I have a valid project on localeapp.com with api key "MYAPIKEY"
-    And the timestamp is 2 months old
-    And new translations for the api key "MYAPIKEY" since last fetch with time "60" seconds later
-    And a directory named "config/locales"
+    Given I have a valid project on localeapp.com with api key "MYAPIKEY"
+      And the timestamp is 2 months old
+      And new translations for the api key "MYAPIKEY" since last fetch with time "60" seconds later
+      And a directory named "config/locales"
     When I run `localeapp -k MYAPIKEY update`
     Then translations should be fetched since last fetch only
-    And help should not be displayed
-    And a file named "config/locales/en.yml" should exist
+      And help should not be displayed
+      And a file named "config/locales/en.yml" should exist
 
   Scenario: Running update with a too old timestamp
     In order to receive the translations that have been updated since the last check
-    When I have a valid project on localeapp.com with api key "MYAPIKEY"
-    And an initializer file
-    And the timestamp is 8 months old
+    Given I have a valid project on localeapp.com with api key "MYAPIKEY"
+      And an initializer file
+      And the timestamp is 8 months old
     When I run `localeapp update`
     Then the output should contain:
     """
     Timestamp is missing or too old
     """
-    And help should not be displayed
+      And help should not be displayed

data/lib/localeapp/version.rb

@@ -1,3 +1,3 @@
 module Localeapp
-  VERSION = '0.9.3'
+  VERSION = '1.0.0'
 end

data/localeapp.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency('i18n')
+  s.add_dependency('i18n', '< 0.7')
   s.add_dependency('json')
   s.add_dependency('rest-client')
   s.add_dependency('rack')
@@ -28,10 +28,10 @@ Gem::Specification.new do |s|
   s.add_dependency('gli')
 
   s.add_development_dependency('rake')
-  s.add_development_dependency('rspec', '~> 2.14.1')
+  s.add_development_dependency('rspec', '~> 3.3')
   s.add_development_dependency('yard')
   s.add_development_dependency('RedCloth')
-  s.add_development_dependency('aruba')
-  s.add_development_dependency('cucumber', '~> 1.3')
+  s.add_development_dependency('aruba', '~> 0.8')
+  s.add_development_dependency('cucumber', '~> 2.0')
   s.add_development_dependency('fakeweb')
 end

data/spec/localeapp/api_call_spec.rb

@@ -8,8 +8,8 @@ describe Localeapp::ApiCall, "#api_call(endpoint, options = {})" do
   it "creates an ApiCaller object and tells it to make the call" do
     api_call_test = ApiCallTest.new
     api_call = double('api_call')
-    api_call.should_receive(:call).with(api_call_test)
-    Localeapp::ApiCaller.should_receive(:new).with(:endpoint, { :foo => :bar }).and_return(api_call)
+    expect(api_call).to receive(:call).with(api_call_test)
+    expect(Localeapp::ApiCaller).to receive(:new).with(:endpoint, { :foo => :bar }).and_return(api_call)
     api_call_test.api_call(:endpoint, { :foo => :bar })
   end
 end

data/spec/localeapp/api_caller_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Localeapp::ApiCaller, ".new(endpoint, options = {})" do
   it "stores the endpoint and options" do
     api_caller = Localeapp::ApiCaller.new(:endpoint, :foo => :bar)
-    api_caller.endpoint.should == :endpoint
-    api_caller.options.should == { :foo => :bar }
+    expect(api_caller.endpoint).to eq(:endpoint)
+    expect(api_caller.options).to eq({ :foo => :bar })
   end
 end
 
@@ -14,39 +14,41 @@ describe Localeapp::ApiCaller, "#call(object)" do
       @api_caller = Localeapp::ApiCaller.new(:test)
     end
     @url = 'https://example.com/test'
-    @api_caller.stub(:test_endpoint).and_return([:get, @url])
-    @api_caller.stub(:sleep_if_retrying)
+    allow(@api_caller).to receive(:test_endpoint).and_return([:get, @url])
+    allow(@api_caller).to receive(:sleep_if_retrying)
   end
 
   it "gets the method and url for the endpoint" do
-    @api_caller.should_receive(:test_endpoint).with({}).and_return([:get, @url])
-    RestClient::Request.stub(:execute).and_return(double('response', :code => 200))
+    expect(@api_caller).to receive(:test_endpoint).with({}).and_return([:get, @url])
+    allow(RestClient::Request).to receive(:execute).and_return(double('response', :code => 200))
     @api_caller.call(self)
   end
 
   it "passes through any url options" do
-    @api_caller.should_receive(:test_endpoint).with({:foo => :bar}).and_return([:get, @url])
+    expect(@api_caller).to receive(:test_endpoint).with({:foo => :bar}).and_return([:get, @url])
     @api_caller.options[:url_options] = { :foo => :bar }
-    RestClient::Request.stub(:execute).and_return(double('response', :code => 200))
+    allow(RestClient::Request).to receive(:execute).and_return(double('response', :code => 200))
     @api_caller.call(self)
   end
 
   it "adds the gem version to the headers" do
-    RestClient::Request.should_receive(:execute).with(hash_including(:headers => { :x_localeapp_gem_version => Localeapp::VERSION })).and_return(double('response', :code => 200))
+    expect(RestClient::Request).to receive(:execute).with(hash_including(:headers => { :x_localeapp_gem_version => Localeapp::VERSION })).and_return(double('response', :code => 200))
     @api_caller.call(self)
   end
 
   if "".respond_to?(:force_encoding)
     def success_check(response)
-      response.encoding.should == Encoding.find('UTF-8')
+      expect(response.encoding).to eq(Encoding.find('UTF-8'))
     end
 
     it "sets the response encoding based on the response charset" do
       response = "string"
-      response.stub(:code).and_return(200)
+      allow(response).to receive(:code).and_return(200)
       response.force_encoding('US-ASCII')
-      response.stub_chain(:net_http_res, :type_params).and_return('charset' => 'utf-8')
-      RestClient::Request.stub(:execute).and_return(response)
+      allow(response).to receive_message_chain(:net_http_res, :type_params) do
+        { "charset" => "utf-8" }
+      end
+      allow(RestClient::Request).to receive(:execute).and_return(response)
       @api_caller.options[:success] = :success_check
       @api_caller.call(self)
     end
@@ -54,17 +56,17 @@ describe Localeapp::ApiCaller, "#call(object)" do
 
   context "Proxy" do
     before do
-      RestClient::Request.stub(:execute).and_return(double('response', :code => 200))
+      allow(RestClient::Request).to receive(:execute).and_return(double('response', :code => 200))
     end
 
     it "sets the proxy if configured" do
       Localeapp.configuration.proxy = "http://localhost:8888"
-      RestClient.should_receive(:proxy=).with('http://localhost:8888')
+      expect(RestClient).to receive(:proxy=).with('http://localhost:8888')
       @api_caller.call(self)
     end
 
     it "doesn't set the proxy if it's not configured" do
-      RestClient.should_not_receive(:proxy=)
+      expect(RestClient).not_to receive(:proxy=)
       @api_caller.call(self)
     end
   end
@@ -72,12 +74,12 @@ describe Localeapp::ApiCaller, "#call(object)" do
   context "SSL Certificate Validation" do
     it "set the HTTPClient verify_ssl to VERIFY_PEER if ssl_verify is set to true" do
       Localeapp.configuration.ssl_verify = true
-      RestClient::Request.should_receive(:execute).with(hash_including(:verify_ssl => OpenSSL::SSL::VERIFY_PEER)).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:verify_ssl => OpenSSL::SSL::VERIFY_PEER)).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
 
     it "set the HTTPClient verify_ssl to false if ssl_verify is set to false" do
-      RestClient::Request.should_receive(:execute).with(hash_including(:verify_ssl => false)).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:verify_ssl => false)).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
   end
@@ -85,13 +87,13 @@ describe Localeapp::ApiCaller, "#call(object)" do
   context "SSL Certificate Validation" do
     it "set the HTTPClient ca_file to the value given to ssl_ca_file if it's not nil" do
       Localeapp.configuration.ssl_ca_file = '/tmp/test'
-      RestClient::Request.should_receive(:execute).with(hash_including(:ca_file => '/tmp/test')).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:ca_file => '/tmp/test')).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
 
     it "doesn't set the HTTPClient ca_file if ssl_ca_file is nil" do
       Localeapp.configuration.ssl_ca_file = nil
-      RestClient::Request.should_receive(:execute).with(hash_not_including(:ca_file => nil)).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_not_including(:ca_file => nil)).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
   end
@@ -99,13 +101,13 @@ describe Localeapp::ApiCaller, "#call(object)" do
   context "SSL version" do
     it "sets the HTTPClient ssl_version to the value given to ssl_version" do
       Localeapp.configuration.ssl_version = 'SSLv3'
-      RestClient::Request.should_receive(:execute).with(hash_including(:ssl_version => 'SSLv3')).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:ssl_version => 'SSLv3')).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
 
     it "doesn't set the HTTPClient ssl_version if it's nil" do
       Localeapp.configuration.ssl_version = nil
-      RestClient::Request.should_receive(:execute).with(hash_including(:ssl_version => nil)).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:ssl_version => nil)).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
   end
@@ -113,19 +115,19 @@ describe Localeapp::ApiCaller, "#call(object)" do
   context "Timeout" do
     it "sets the timeout to the configured timeout" do
       Localeapp.configuration.timeout = 120
-      RestClient::Request.should_receive(:execute).with(hash_including(:timeout => 120)).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:timeout => 120)).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
   end
 
   context "a GET request" do
     it "makes the call to the api" do
-      RestClient::Request.should_receive(:execute).with(hash_including(:url => @url, :method => :get)).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:url => @url, :method => :get)).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
 
     it "adds any :headers to the api call" do
-      RestClient::Request.should_receive(:execute).with(hash_including(:headers => { :x_localeapp_gem_version => Localeapp::VERSION, :foo => :bar })).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:headers => { :x_localeapp_gem_version => Localeapp::VERSION, :foo => :bar })).and_return(double('response', :code => 200))
       @api_caller.options[:headers] = { :foo => :bar }
       @api_caller.call(self)
     end
@@ -134,17 +136,17 @@ describe Localeapp::ApiCaller, "#call(object)" do
 
   context " a POST request" do
     before do
-      @api_caller.stub(:test_endpoint).and_return([:post, @url])
+      allow(@api_caller).to receive(:test_endpoint).and_return([:post, @url])
       @api_caller.options[:payload] = "test data"
     end
 
     it "makes the call to the api using :payload as the payload" do
-      RestClient::Request.should_receive(:execute).with(hash_including(:url => @url, :payload => "test data", :method => :post)).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:url => @url, :payload => "test data", :method => :post)).and_return(double('response', :code => 200))
       @api_caller.call(self)
     end
 
     it "adds any :headers to the api call" do
-      RestClient::Request.should_receive(:execute).with(hash_including(:headers => { :x_localeapp_gem_version => Localeapp::VERSION, :foo => :bar })).and_return(double('response', :code => 200))
+      expect(RestClient::Request).to receive(:execute).with(hash_including(:headers => { :x_localeapp_gem_version => Localeapp::VERSION, :foo => :bar })).and_return(double('response', :code => 200))
       @api_caller.options[:headers] = { :foo => :bar }
       @api_caller.call(self)
     end
@@ -158,24 +160,24 @@ describe Localeapp::ApiCaller, "#call(object)" do
 
     it "calls the :success option callback if present" do
       @api_caller.options[:success] = :success
-      @object.should_receive(:success).with(kind_of(RestClient::Response))
+      expect(@object).to receive(:success).with(kind_of(RestClient::Response))
       @api_caller.call(@object)
     end
 
     it "does nothing if :success option callback not present" do
-      @object.should_not_receive(:success)
+      expect(@object).not_to receive(:success)
       @api_caller.call(@object)
     end
 
     it "should not try the call again" do
       @api_caller.max_connection_attempts = 2
       @api_caller.call(@object)
-      @api_caller.connection_attempts.should == 1
+      expect(@api_caller.connection_attempts).to eq(1)
     end
 
     it "doesn't call the failure handler" do
       @api_caller.options[:failure] = :failure
-      @object.should_not_receive(:failure)
+      expect(@object).not_to receive(:failure)
       @api_caller.call(@object)
     end
   end
@@ -189,22 +191,22 @@ describe Localeapp::ApiCaller, "#call(object)" do
     it "retries call, up to value of :max_connection_attempts option" do
       @api_caller.max_connection_attempts = 2
       @api_caller.call(@object)
-      @api_caller.connection_attempts.should == 2
+      expect(@api_caller.connection_attempts).to eq(2)
     end
 
     it "backs off each retry attempt" do
-      @api_caller.should_receive(:sleep_if_retrying)
+      expect(@api_caller).to receive(:sleep_if_retrying)
       @api_caller.call(@object)
     end
 
     it "calls the :failure option callback if present" do
       @api_caller.options[:failure] = :fail
-      @object.should_receive(:fail).with(kind_of(RestClient::Response))
+      expect(@object).to receive(:fail).with(kind_of(RestClient::Response))
       @api_caller.call(@object)
     end
 
     it "does nothing if :failure option callback not present" do
-      @object.should_not_receive(:fail)
+      expect(@object).not_to receive(:fail)
       @api_caller.call(@object)
     end
 
@@ -232,29 +234,29 @@ describe Localeapp::ApiCaller, "#call(object)" do
       it "fails when response is #{code} #{reason}" do
         FakeWeb.register_uri(:get, @url, :body => '', :status => [code.to_s, reason])
         @api_caller.options[:failure] = :fail
-        @object.should_receive(:fail)
+        expect(@object).to receive(:fail)
         @api_caller.call(@object)
       end
     end
 
     it "handles ECONNREFUSED" do
-      RestClient::Request.stub(:execute).and_raise(Errno::ECONNREFUSED)
+      allow(RestClient::Request).to receive(:execute).and_raise(Errno::ECONNREFUSED)
       @api_caller.options[:failure] = :fail
-      @object.should_receive(:fail)
+      expect(@object).to receive(:fail)
       @api_caller.call(@object)
     end
 
     it "handles RestClient::ServerBrokeConnection" do
-      RestClient::Request.stub(:execute).and_raise(RestClient::ServerBrokeConnection)
+      allow(RestClient::Request).to receive(:execute).and_raise(RestClient::ServerBrokeConnection)
       @api_caller.options[:failure] = :fail
-      @object.should_receive(:fail)
+      expect(@object).to receive(:fail)
       @api_caller.call(@object)
     end
 
     it "handles SocketError" do
-      RestClient::Request.stub(:execute).and_raise(SocketError)
+      allow(RestClient::Request).to receive(:execute).and_raise(SocketError)
       @api_caller.options[:failure] = :fail
-      @object.should_receive(:fail)
+      expect(@object).to receive(:fail)
       @api_caller.call(@object)
     end
   end

data/spec/localeapp/cli/add_spec.rb

@@ -13,34 +13,34 @@ describe Localeapp::CLI::Add, "#execute(key, *translations)" do
 
   it "adds the translations to missing_translations" do
     with_configuration do
-      Localeapp.sender.stub(:post_missing_translations)
+      allow(Localeapp.sender).to receive(:post_missing_translations)
       do_action
     end
     en_missing = Localeapp.missing_translations['en']
-    en_missing.size.should == 1
-    en_missing['test.key'].locale.should == 'en'
-    en_missing['test.key'].description.should == 'test en'
+    expect(en_missing.size).to eq(1)
+    expect(en_missing['test.key'].locale).to eq('en')
+    expect(en_missing['test.key'].description).to eq('test en')
     es_missing = Localeapp.missing_translations['es']
-    es_missing.size.should == 1
-    es_missing['test.key'].locale.should == 'es'
-    es_missing['test.key'].description.should == 'test es'
+    expect(es_missing.size).to eq(1)
+    expect(es_missing['test.key'].locale).to eq('es')
+    expect(es_missing['test.key'].description).to eq('test es')
   end
 
   it "ignores badly formed arguments" do
     with_configuration do
-      Localeapp.sender.stub(:post_missing_translations)
+      allow(Localeapp.sender).to receive(:post_missing_translations)
       do_action('test.key', ["en:this is fine", "esbad"])
     end
-    Localeapp.missing_translations['en'].size.should == 1
-    Localeapp.missing_translations['es'].size.should == 0
-    Localeapp.missing_translations['esbad'].size.should == 0
-    @output.string.should include("Ignoring bad translation esbad")
-    @output.string.should include("format should be <locale>:<translation content>")
+    expect(Localeapp.missing_translations['en'].size).to eq(1)
+    expect(Localeapp.missing_translations['es'].size).to eq(0)
+    expect(Localeapp.missing_translations['esbad'].size).to eq(0)
+    expect(@output.string).to include("Ignoring bad translation esbad")
+    expect(@output.string).to include("format should be <locale>:<translation content>")
   end
 
   it "tells the sender to send the missing translations" do
     with_configuration do
-      Localeapp.sender.should_receive(:post_missing_translations)
+      expect(Localeapp.sender).to receive(:post_missing_translations)
       do_action
     end
   end

data/spec/localeapp/cli/daemon_spec.rb

@@ -6,21 +6,21 @@ describe Localeapp::CLI::Daemon, "#execute(options)" do
   let(:interval) { 5 }
 
   before do
-    command.stub(:update_loop)
+    allow(command).to receive(:update_loop)
   end
 
   it "exits when interval isn't greater than 0" do
-    command.should_receive(:exit_now!)
+    expect(command).to receive(:exit_now!)
     command.execute(:interval => -1)
   end
 
   it "runs the loop directly when not running in background" do
-    command.should_receive(:update_loop).with(interval)
+    expect(command).to receive(:update_loop).with(interval)
     command.execute(:interval => interval)
   end
 
   it "runs the loop in the background when background options set" do
-    command.should_receive(:run_in_background).with(interval)
+    expect(command).to receive(:run_in_background).with(interval)
     command.execute(:interval => interval, :background => true)
   end
 end
@@ -31,8 +31,8 @@ describe Localeapp::CLI::Daemon, "#do_update" do
 
   it "creates and executes and Updater" do
     stub = double(:updater)
-    stub.should_receive(:execute)
-    Localeapp::CLI::Update.should_receive(:new).and_return(stub)
+    expect(stub).to receive(:execute)
+    expect(Localeapp::CLI::Update).to receive(:new).and_return(stub)
     command.do_update
   end
 end