contentful 0.3.4 → 0.3.5

data/spec/auto_includes_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe 'Auto-include resources' do
-  let(:entries){ vcr('entries'){ create_client.entries } } # entries come with asset includes
+  let(:entries) { vcr('entries') { create_client.entries } } # entries come with asset includes
 
   it 'replaces Contentful::Links which are actually included with the resource' do
     asset = entries.items[1].fields[:image]
 
-    expect( asset ).not_to be_a Contentful::Link
-    expect( asset ).to be_a Contentful::Asset
+    expect(asset).not_to be_a Contentful::Link
+    expect(asset).to be_a Contentful::Asset
   end
-end
+end

data/spec/client_class_spec.rb

@@ -1,57 +1,55 @@
 require 'spec_helper'
 
-
 describe Contentful::Client do
   describe '#get' do
-    let(:client){ create_client }
-    let(:request){
+    let(:client) { create_client }
+    let(:request)do
       Contentful::Request.new(nil, '/content_types', nil, 'cat')
-    }
-
+    end
 
     it 'uses #base_url' do
-      stub(client).base_url{ "https://cdn.contentful.com/spaces/cfexampleapi" }
-      vcr('content_type'){ client.get(request) }
-      expect( client ).to have_received.base_url
+      stub(client).base_url { 'https://cdn.contentful.com/spaces/cfexampleapi' }
+      vcr('content_type') { client.get(request) }
+      expect(client).to have_received.base_url
     end
 
     it 'uses #request_headers' do
-      stub(client).request_headers{{
+      stub(client).request_headers do{
         'User-Agent' => 'RubyContentfulGem/0.1.0',
         'Authorization' => 'Bearer b4c0n73n7fu1',
         'Content-Type' => 'application/vnd.contentful.delivery.v1+json',
-      }}
-      vcr('content_type'){ client.get(request) }
-      expect( client ).to have_received.request_headers
+      }end
+      vcr('content_type') { client.get(request) }
+      expect(client).to have_received.request_headers
     end
 
     it 'uses Request#url' do
-      stub(request).url{ "/content_types/cat" }
-      vcr('content_type'){ client.get(request) }
-      expect( request ).to have_received.url
+      stub(request).url { '/content_types/cat' }
+      vcr('content_type') { client.get(request) }
+      expect(request).to have_received.url
     end
 
     it 'uses Request#query' do
       stub(request).query
-      vcr('content_type'){ client.get(request) }
-      expect( request ).to have_received.query
+      vcr('content_type') { client.get(request) }
+      expect(request).to have_received.query
     end
 
     it 'calls #get_http' do
-      stub(client.class).get_http{ raw_fixture('content_type') }
+      stub(client.class).get_http { raw_fixture('content_type') }
       client.get(request)
-      expect( client.class ).to have_received.get_http(client.base_url + request.url, request.query, client.request_headers)
+      expect(client.class).to have_received.get_http(client.base_url + request.url, request.query, client.request_headers)
     end
 
     describe 'build_resources parameter' do
       it 'returns Contentful::Resource object if second parameter is true [default]' do
-        res = vcr('content_type'){ client.get(request) }
-        expect( res ).to be_a Contentful::Resource
+        res = vcr('content_type') { client.get(request) }
+        expect(res).to be_a Contentful::Resource
       end
 
       it 'returns a Contentful::Response object if second parameter is not true' do
-        res = vcr('content_type'){ client.get(request, false) }
-        expect( res ).to be_a Contentful::Response
+        res = vcr('content_type') { client.get(request, false) }
+        expect(res).to be_a Contentful::Response
       end
     end
 
@@ -59,7 +57,7 @@ describe Contentful::Client do
 
   describe '#sync' do
     it 'creates a new Sync object' do
-      expect( create_client.sync ).to be_a Contentful::Sync
+      expect(create_client.sync).to be_a Contentful::Sync
     end
   end
 end

data/spec/client_configuration_spec.rb

@@ -1,20 +1,19 @@
 require 'spec_helper'
 
-
 describe 'Client Configuration Options' do
   describe ':space' do
     it 'is required' do
-      expect{
+      expect do
         Contentful::Client.new(access_token: 'b4c0n73n7fu1')
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
   describe ':access_token' do
     it 'is required' do
-      expect{
+      expect do
         Contentful::Client.new(space: 'cfexampleapi')
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -34,42 +33,42 @@ describe 'Client Configuration Options' do
 
   describe ':raise_errors' do
     it 'will raise response errors if set to true [default]' do
-      expect_vcr('not found'){
-        create_client.entry "not found"
-      }.to raise_error Contentful::NotFound
+      expect_vcr('not found')do
+        create_client.entry 'not found'
+      end.to raise_error Contentful::NotFound
     end
 
     it 'will not raise response errors if set to false' do
       res = nil
 
-      expect_vcr('not found'){
-        res = create_client(raise_errors: false).entry "not found"
-      }.not_to raise_error
-      expect( res ).to be_instance_of Contentful::NotFound
+      expect_vcr('not found')do
+        res = create_client(raise_errors: false).entry 'not found'
+      end.not_to raise_error
+      expect(res).to be_instance_of Contentful::NotFound
     end
   end
 
   describe ':dynamic_entries' do
     it 'will create static if dynamic_entry_cache is empty' do
-      entry = vcr('nyancat'){ create_client(dynamic_entries: :manual).entry('nyancat') }
-      expect( entry ).not_to be_a Contentful::DynamicEntry
+      entry = vcr('nyancat') { create_client(dynamic_entries: :manual).entry('nyancat') }
+      expect(entry).not_to be_a Contentful::DynamicEntry
     end
 
     it 'will create dynamic entries if dynamic_entry_cache is not empty' do
       client = create_client(dynamic_entries: :manual)
-      vcr('entry_cache'){ client.update_dynamic_entry_cache! }
-      entry = vcr('nyancat'){ client.entry('nyancat') }
+      vcr('entry_cache') { client.update_dynamic_entry_cache! }
+      entry = vcr('nyancat') { client.entry('nyancat') }
 
-      expect( entry ).to be_a Contentful::DynamicEntry
+      expect(entry).to be_a Contentful::DynamicEntry
     end
 
     context ':auto' do
       it 'will call update dynamic_entry_cache on start-up' do
-        client = vcr('entry_cache'){
-           create_client(dynamic_entries: :auto)
-        }
-        expect( client.dynamic_entry_cache ).not_to be_empty
-        expect( client.dynamic_entry_cache.values.first.ancestors ).to \
+        client = vcr('entry_cache')do
+          create_client(dynamic_entries: :auto)
+        end
+        expect(client.dynamic_entry_cache).not_to be_empty
+        expect(client.dynamic_entry_cache.values.first.ancestors).to \
             include Contentful::DynamicEntry
       end
     end
@@ -77,40 +76,40 @@ describe 'Client Configuration Options' do
     context ':manual' do
       it 'will not call #update_dynamic_entry_cache! on start-up' do
         client = create_client(dynamic_entries: :manual)
-        expect( client.dynamic_entry_cache ).to be_empty
+        expect(client.dynamic_entry_cache).to be_empty
       end
     end
 
     describe '#update_dynamic_entry_cache!' do
-      let(:client){ create_client(dynamic_entries: :manual) }
+      let(:client) { create_client(dynamic_entries: :manual) }
 
       it 'will fetch all content_types' do
-        stub(client).content_types{{}}
+        stub(client).content_types { {} }
         client.update_dynamic_entry_cache!
-        expect( client ).to have_received.content_types(limit: 1000)
+        expect(client).to have_received.content_types(limit: 1000)
       end
 
       it 'will save dynamic entries in @dynamic_entry_cache' do
-        vcr('entry_cache'){
+        vcr('entry_cache')do
           client.update_dynamic_entry_cache!
-        }
-        expect( client.dynamic_entry_cache ).not_to be_empty
-        expect( client.dynamic_entry_cache.values.first.ancestors ).to \
+        end
+        expect(client.dynamic_entry_cache).not_to be_empty
+        expect(client.dynamic_entry_cache.values.first.ancestors).to \
             include Contentful::DynamicEntry
       end
     end
 
     describe '#register_dynamic_entry' do
-      let(:client){ create_client(dynamic_entries: :manual) }
+      let(:client) { create_client(dynamic_entries: :manual) }
 
       it 'can be used to register a dynamic entry manually' do
-        cat = vcr('content_type'){ client.content_type 'cat' }
+        cat = vcr('content_type') { client.content_type 'cat' }
         CatEntry = Contentful::DynamicEntry.create(cat)
         client.register_dynamic_entry 'cat', CatEntry
 
-        entry = vcr('nyancat'){ client.entry('nyancat') }
-        expect( entry ).to be_a Contentful::DynamicEntry
-        expect( entry ).to be_a CatEntry
+        entry = vcr('nyancat') { client.entry('nyancat') }
+        expect(entry).to be_a Contentful::DynamicEntry
+        expect(entry).to be_a CatEntry
       end
     end
   end
@@ -119,13 +118,13 @@ describe 'Client Configuration Options' do
     it 'is "cdn.contentful.com" [default]' do
       expect(
         create_client.configuration[:api_url]
-      ).to eq "cdn.contentful.com"
+      ).to eq 'cdn.contentful.com'
     end
 
     it 'will be used as base url' do
       expect(
-        create_client(api_url: "cdn2.contentful.com").base_url
-      ).to start_with "https://cdn2.contentful.com"
+        create_client(api_url: 'cdn2.contentful.com').base_url
+      ).to start_with 'https://cdn2.contentful.com'
     end
   end
 
@@ -139,7 +138,7 @@ describe 'Client Configuration Options' do
     it 'will used for the http content type request header' do
       expect(
         create_client(api_version: 2).request_headers['Content-Type']
-      ).to eq "application/vnd.contentful.delivery.v2+json"
+      ).to eq 'application/vnd.contentful.delivery.v2+json'
     end
   end
 
@@ -148,7 +147,7 @@ describe 'Client Configuration Options' do
       it 'will add the :access_token as authorization bearer token request header' do
         expect(
           create_client.request_headers['Authorization']
-        ).to eq "Bearer b4c0n73n7fu1"
+        ).to eq 'Bearer b4c0n73n7fu1'
       end
 
       it 'will not add :access_token to query' do
@@ -163,7 +162,7 @@ describe 'Client Configuration Options' do
         expect(
           create_client(authentication_mechanism: :query_string).
               request_query({})['access_token']
-        ).to eq "b4c0n73n7fu1"
+        ).to eq 'b4c0n73n7fu1'
       end
 
       it 'will not add the :access_token as authorization bearer token request header' do
@@ -179,7 +178,7 @@ describe 'Client Configuration Options' do
     it 'lets you register your own resource classes for certain response types' do
       class MyBetterAsset < Contentful::Asset
         def https_image_url
-          image_url.sub %r<\A//>, 'https://'
+          image_url.sub %r{\A//}, 'https://'
         end
       end
 
@@ -189,9 +188,9 @@ describe 'Client Configuration Options' do
         }
       )
 
-      nyancat = vcr('asset'){ client.asset 'nyancat' }
-      expect( nyancat ).to be_a MyBetterAsset
-      expect( nyancat.https_image_url ).to start_with 'https'
+      nyancat = vcr('asset') { client.asset 'nyancat' }
+      expect(nyancat).to be_a MyBetterAsset
+      expect(nyancat.https_image_url).to start_with 'https'
     end
   end
 
@@ -207,10 +206,10 @@ describe 'Client Configuration Options' do
         }
       )
 
-      nyancat = vcr('entry'){ client.entry 'nyancat' }
-      finn    = vcr('human'){ client.entry 'finn' }
-      expect( nyancat ).to be_a Cat
-      expect( finn    ).to be_a Contentful::Entry
+      nyancat = vcr('entry') { client.entry 'nyancat' }
+      finn    = vcr('human') { client.entry 'finn' }
+      expect(nyancat).to be_a Cat
+      expect(finn).to be_a Contentful::Entry
     end
   end
 end

data/spec/coercions_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe 'Coercion Examples' do
-  let(:entry){ vcr("entry"){ create_client.entry 'nyancat' } }
+  let(:entry) { vcr('entry') { create_client.entry 'nyancat' } }
 
   it 'converts contentful to ruby DateTime objects' do
-    expect( entry.created_at ).to be_a DateTime
-    expect( entry.created_at.day ).to eq 27
+    expect(entry.created_at).to be_a DateTime
+    expect(entry.created_at.day).to eq 27
   end
-end
+end

data/spec/content_type_spec.rb

@@ -1,44 +1,44 @@
 require 'spec_helper'
 
 describe Contentful::ContentType do
-  let(:content_type){ vcr('content_type'){ create_client.content_type 'cat' } }
+  let(:content_type) { vcr('content_type') { create_client.content_type 'cat' } }
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
-      expect( content_type.sys ).to be_a Hash
-      expect( content_type.sys.keys.sample ).to be_a Symbol
+      expect(content_type.sys).to be_a Hash
+      expect(content_type.sys.keys.sample).to be_a Symbol
     end
 
     it 'has #id' do
-      expect( content_type.id ).to eq "cat"
+      expect(content_type.id).to eq 'cat'
     end
 
     it 'has #type' do
-      expect( content_type.type ).to eq "ContentType"
+      expect(content_type.type).to eq 'ContentType'
     end
   end
 
   describe 'Properties' do
     it 'has a #properties getter returning a hash with symbol keys' do
-      expect( content_type.properties ).to be_a Hash
-      expect( content_type.properties.keys.sample ).to be_a Symbol
+      expect(content_type.properties).to be_a Hash
+      expect(content_type.properties.keys.sample).to be_a Symbol
     end
 
     it 'has #name' do
-      expect( content_type.name ).to eq "Cat"
+      expect(content_type.name).to eq 'Cat'
     end
 
     it 'has #description' do
-      expect( content_type.description ).to eq "Meow."
+      expect(content_type.description).to eq 'Meow.'
     end
 
     it 'has #fields' do
-      expect( content_type.fields ).to be_a Array
-      expect( content_type.fields.first ).to be_a Contentful::Field
+      expect(content_type.fields).to be_a Array
+      expect(content_type.fields.first).to be_a Contentful::Field
     end
 
     it 'could have #display_field' do
-      expect( content_type ).to respond_to :display_field
+      expect(content_type).to respond_to :display_field
     end
   end
 end

data/spec/deleted_asset_spec.rb

@@ -1,29 +1,28 @@
 require 'spec_helper'
 
-
 describe 'DeletedAsset' do
-  let(:deleted_asset){
-    vcr('sync_deleted_asset'){
+  let(:deleted_asset)do
+    vcr('sync_deleted_asset')do
       create_client.sync(initial: true, type: 'DeletedAsset').first_page.items[0]
-    }
-  }
+    end
+  end
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
-      expect( deleted_asset.sys ).to be_a Hash
-      expect( deleted_asset.sys.keys.sample ).to be_a Symbol
+      expect(deleted_asset.sys).to be_a Hash
+      expect(deleted_asset.sys.keys.sample).to be_a Symbol
     end
 
     it 'has #id' do
-      expect( deleted_asset.id ).to eq "5c6VY0gWg0gwaIeYkUUiqG"
+      expect(deleted_asset.id).to eq '5c6VY0gWg0gwaIeYkUUiqG'
     end
 
     it 'has #type' do
-      expect( deleted_asset.type ).to eq "DeletedAsset"
+      expect(deleted_asset.type).to eq 'DeletedAsset'
     end
 
     it 'has #deleted_at' do
-      expect( deleted_asset.created_at ).to be_a DateTime
+      expect(deleted_asset.created_at).to be_a DateTime
     end
   end
-end
+end

data/spec/deleted_entry_spec.rb

@@ -1,29 +1,28 @@
 require 'spec_helper'
 
-
 describe 'DeletedEntry' do
-  let(:deleted_entry){
-    vcr('sync_deleted_entry'){
+  let(:deleted_entry)do
+    vcr('sync_deleted_entry')do
       create_client.sync(initial: true, type: 'DeletedEntry').first_page.items[0]
-    }
-  }
+    end
+  end
 
   describe 'SystemProperties' do
     it 'has a #sys getter returning a hash with symbol keys' do
-      expect( deleted_entry.sys ).to be_a Hash
-      expect( deleted_entry.sys.keys.sample ).to be_a Symbol
+      expect(deleted_entry.sys).to be_a Hash
+      expect(deleted_entry.sys.keys.sample).to be_a Symbol
     end
 
     it 'has #id' do
-      expect( deleted_entry.id ).to eq "CVebBDcQsSsu6yKKIayy"
+      expect(deleted_entry.id).to eq 'CVebBDcQsSsu6yKKIayy'
     end
 
     it 'has #type' do
-      expect( deleted_entry.type ).to eq "DeletedEntry"
+      expect(deleted_entry.type).to eq 'DeletedEntry'
     end
 
     it 'has #deleted_at' do
-      expect( deleted_entry.created_at ).to be_a DateTime
+      expect(deleted_entry.created_at).to be_a DateTime
     end
   end
 end