asset_cloud 2.7.1 → 2.7.2

data/spec/base_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 class SpecialAsset < AssetCloud::Asset
 end
@@ -16,182 +17,182 @@ end
 class BasicCloud < AssetCloud::Base
   bucket :special, AssetCloud::MemoryBucket, asset_class: SpecialAsset
   bucket :conditional, AssetCloud::MemoryBucket, asset_class: proc { |key|
-    LiquidAsset if key.ends_with?('.liquid')
+    LiquidAsset if key.ends_with?(".liquid")
   }
   bucket :broken, BrokenBucket, asset_class: AssetCloud::Asset
 end
 
 describe BasicCloud do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before do
-    @fs = BasicCloud.new(directory, 'http://assets/files')
+    @fs = BasicCloud.new(directory, "http://assets/files")
   end
 
   it "should raise invalid bucket if none is given" do
-    expect(@fs['image.jpg'].exist?).to(eq(false))
+    expect(@fs["image.jpg"].exist?).to(eq(false))
   end
 
   it "should be backed by a file system bucket" do
-    expect(@fs['products/key.txt'].exist?).to(eq(true))
+    expect(@fs["products/key.txt"].exist?).to(eq(true))
   end
 
   it "should raise when listing non existing buckets" do
-    expect(@fs.ls('products')).to(eq([AssetCloud::Asset.new(@fs, 'products/key.txt')]))
+    expect(@fs.ls("products")).to(eq([AssetCloud::Asset.new(@fs, "products/key.txt")]))
   end
 
   it "should allow you to create new assets" do
-    obj = @fs.build('new_file.test')
+    obj = @fs.build("new_file.test")
     expect(obj).to(be_an_instance_of(AssetCloud::Asset))
     expect(obj.cloud).to(be_an_instance_of(BasicCloud))
   end
 
   it "should raise error when using with minus relative or absolute paths" do
-    expect { @fs['../test']  }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['/test']    }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['.../test'] }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['./test']   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["../test"]  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["/test"]    }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs[".../test"] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["./test"]   }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when filename has trailing period" do
-    expect { @fs['test.']             }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['/test/testfile.']   }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/directory/.']  }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['/test/testfile .']  }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/directory /.'] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test."]             }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["/test/testfile."]   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/directory/."]  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["/test/testfile ."]  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/directory /."] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when filename ends with space" do
-    expect { @fs['test ']             }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['/test/testfile ']   }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/directory/ ']  }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test. ']            }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['/test/testfile. ']  }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/directory/. '] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test "]             }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["/test/testfile "]   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/directory/ "]  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test. "]            }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["/test/testfile. "]  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/directory/. "] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when filename ends with slash" do
-    expect { @fs['test/']             }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/directory/']   }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test /']            }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['/test/testfile /']  }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/directory//']  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/"]             }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/directory/"]   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test /"]            }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["/test/testfile /"]  }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/directory//"]  }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise error when using with minus relative even after another directory" do
-    expect { @fs['test/../test']      }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/../../test']   }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test/../../../test'] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/../test"]      }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/../../test"]   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test/../../../test"] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should raise an error when using names with combinations of '.' and ' '" do
-    expect { @fs['test. . . .. ... .. . ']   }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test. .'] }.to(raise_error(AssetCloud::IllegalPath))
-    expect { @fs['test.   .test2'] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test. . . .. ... .. . "]   }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test. ."] }.to(raise_error(AssetCloud::IllegalPath))
+    expect { @fs["test.   .test2"] }.to(raise_error(AssetCloud::IllegalPath))
   end
 
   it "should allow filenames with repeating dots" do
-    @fs['test..jpg']
-    @fs['assets/T.T..jpg']
-    @fs['test/assets/1234123412341234_obj_description..14...58......v8...._2134123412341234.jpg']
+    @fs["test..jpg"]
+    @fs["assets/T.T..jpg"]
+    @fs["test/assets/1234123412341234_obj_description..14...58......v8...._2134123412341234.jpg"]
   end
 
   it "should allow filenames with repeating underscores" do
-    @fs['test__jpg']
-    @fs['assets/T__T..jpg']
-    @fs['test/assets/1234123412341234_obj_description..14...58......v8...__2134123412341234.jpg']
+    @fs["test__jpg"]
+    @fs["assets/T__T..jpg"]
+    @fs["test/assets/1234123412341234_obj_description..14...58......v8...__2134123412341234.jpg"]
   end
 
   it "should allow filenames with various bracket arragements" do
-    @fs['test[1].jpg']
-    @fs['test[1]']
-    @fs['[test].jpg']
+    @fs["test[1].jpg"]
+    @fs["test[1]"]
+    @fs["[test].jpg"]
   end
 
   it "should not raise an error when using directory names with spaces" do
-    @fs['files/ass ets/.DS_Store']
+    @fs["files/ass ets/.DS_Store"]
   end
 
   it "should not raise_error when using unusual but valid filenames" do
-    @fs['.DS_Store']
-    @fs['photograph.g']
-    @fs['_testfilename']
-    @fs['assets/.DS_Store']
-    @fs['assets/photograph.g']
-    @fs['a/_testfilename']
-    @fs['a']
+    @fs[".DS_Store"]
+    @fs["photograph.g"]
+    @fs["_testfilename"]
+    @fs["assets/.DS_Store"]
+    @fs["assets/photograph.g"]
+    @fs["a/_testfilename"]
+    @fs["a"]
   end
 
   it "should allow sensible relative filenames" do
-    @fs['assets/rails_logo.gif']
-    @fs['assets/rails_logo']
-    @fs['assets/rails-2.gif']
-    @fs['assets/223434.gif']
-    @fs['files/1.JPG']
+    @fs["assets/rails_logo.gif"]
+    @fs["assets/rails_logo"]
+    @fs["assets/rails-2.gif"]
+    @fs["assets/223434.gif"]
+    @fs["files/1.JPG"]
   end
 
   it "should compute complete urls to assets" do
-    expect(@fs.url_for('products/[key] with spaces.txt?foo=1&bar=2')).to(eq('http://assets/files/products/[key]%20with%20spaces.txt?foo=1&bar=2'))
+    expect(@fs.url_for("products/[key] with spaces.txt?foo=1&bar=2")).to(eq("http://assets/files/products/[key]%20with%20spaces.txt?foo=1&bar=2"))
   end
 
   describe "#find" do
     it "should return the appropriate asset when one exists" do
-      asset = @fs.find('products/key.txt')
-      expect(asset.key).to(eq('products/key.txt'))
-      expect(asset.value).to(eq('value'))
+      asset = @fs.find("products/key.txt")
+      expect(asset.key).to(eq("products/key.txt"))
+      expect(asset.value).to(eq("value"))
     end
     it "should raise AssetNotFoundError when the asset doesn't exist" do
-      expect { @fs.find('products/not-there.txt') }.to(raise_error(AssetCloud::AssetNotFoundError))
+      expect { @fs.find("products/not-there.txt") }.to(raise_error(AssetCloud::AssetNotFoundError))
     end
   end
 
   describe "#[]" do
     it "should return the appropriate asset when one exists" do
-      asset = @fs['products/key.txt']
-      expect(asset.key).to(eq('products/key.txt'))
-      expect(asset.value).to(eq('value'))
+      asset = @fs["products/key.txt"]
+      expect(asset.key).to(eq("products/key.txt"))
+      expect(asset.value).to(eq("value"))
     end
     it "should not raise any errors when the asset doesn't exist" do
-      expect { @fs['products/not-there.txt'] }.not_to(raise_error)
+      expect { @fs["products/not-there.txt"] }.not_to(raise_error)
     end
   end
 
   describe "#move" do
     it "should return move a resource" do
-      asset = @fs['products/key.txt']
-      expect(asset.key).to(eq('products/key.txt'))
-      expect(asset.value).to(eq('value'))
-      @fs.move('products/key.txt', 'products/key2.txt')
-      new_asset = @fs['products/key2.txt']
-      expect(new_asset.key).to(eq('products/key2.txt'))
-      expect(new_asset.value).to(eq('value'))
-      expect { @fs['products/key.txt'].value }.to(raise_error(AssetCloud::AssetNotFoundError))
-      @fs.move('products/key2.txt', 'products/key.txt')
+      asset = @fs["products/key.txt"]
+      expect(asset.key).to(eq("products/key.txt"))
+      expect(asset.value).to(eq("value"))
+      @fs.move("products/key.txt", "products/key2.txt")
+      new_asset = @fs["products/key2.txt"]
+      expect(new_asset.key).to(eq("products/key2.txt"))
+      expect(new_asset.value).to(eq("value"))
+      expect { @fs["products/key.txt"].value }.to(raise_error(AssetCloud::AssetNotFoundError))
+      @fs.move("products/key2.txt", "products/key.txt")
     end
   end
 
   describe "#[]=" do
     it "should write through the Asset object (and thus run any callbacks on the asset)" do
       special_asset = double(:special_asset)
-      expect(special_asset).to(receive(:value=).with('fancy fancy!'))
+      expect(special_asset).to(receive(:value=).with("fancy fancy!"))
       expect(special_asset).to(receive(:store))
       expect(SpecialAsset).to(receive(:at).and_return(special_asset))
-      @fs['special/fancy.txt'] = 'fancy fancy!'
+      @fs["special/fancy.txt"] = "fancy fancy!"
     end
   end
 
   describe "#bucket" do
     it "should allow specifying a class to use for assets in this bucket" do
-      expect(@fs['assets/rails_logo.gif']).to(be_instance_of(AssetCloud::Asset))
-      expect(@fs['special/fancy.txt']).to(be_instance_of(SpecialAsset))
+      expect(@fs["assets/rails_logo.gif"]).to(be_instance_of(AssetCloud::Asset))
+      expect(@fs["special/fancy.txt"]).to(be_instance_of(SpecialAsset))
 
-      expect(@fs.build('assets/foo')).to(be_instance_of(AssetCloud::Asset))
-      expect(@fs.build('special/foo')).to(be_instance_of(SpecialAsset))
+      expect(@fs.build("assets/foo")).to(be_instance_of(AssetCloud::Asset))
+      expect(@fs.build("special/foo")).to(be_instance_of(SpecialAsset))
     end
 
     it "should allow specifying a proc that determines the class to use, using the default bucket when returning nil" do
-      expect(@fs.build('conditional/default.js')).to(be_instance_of(AssetCloud::Asset))
-      expect(@fs.build('conditional/better.liquid')).to(be_instance_of(LiquidAsset))
+      expect(@fs.build("conditional/default.js")).to(be_instance_of(AssetCloud::Asset))
+      expect(@fs.build("conditional/better.liquid")).to(be_instance_of(LiquidAsset))
     end
 
     it "should raise " do
@@ -202,30 +203,30 @@ describe BasicCloud do
   describe "write!" do
     it "should write through the Asset object (and thus run any callbacks on the asset)" do
       special_asset = double(:special_asset)
-      expect(special_asset).to(receive(:value=).with('fancy fancy!'))
+      expect(special_asset).to(receive(:value=).with("fancy fancy!"))
       expect(special_asset).to(receive(:store!))
       expect(SpecialAsset).to(receive(:at).and_return(special_asset))
-      @fs.write!('special/fancy.txt', 'fancy fancy!')
+      @fs.write!("special/fancy.txt", "fancy fancy!")
     end
 
     it "should raise AssetNotSaved when write fails" do
-      expect { @fs.write!('broken/file.txt', 'n/a') }.to(raise_error(AssetCloud::AssetNotSaved))
+      expect { @fs.write!("broken/file.txt", "n/a") }.to(raise_error(AssetCloud::AssetNotSaved))
     end
   end
 
   describe "MATCH_BUCKET" do
     it "should match following stuff " do
-      'products/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      expect(Regexp.last_match(1)).to(eq('products'))
+      "products/key.txt" =~ AssetCloud::Base::MATCH_BUCKET
+      expect(Regexp.last_match(1)).to(eq("products"))
 
-      'products/subpath/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      expect(Regexp.last_match(1)).to(eq('products'))
+      "products/subpath/key.txt" =~ AssetCloud::Base::MATCH_BUCKET
+      expect(Regexp.last_match(1)).to(eq("products"))
 
-      'key.txt' =~ AssetCloud::Base::MATCH_BUCKET
+      "key.txt" =~ AssetCloud::Base::MATCH_BUCKET
       expect(Regexp.last_match(1)).to(eq(nil))
 
-      'products' =~ AssetCloud::Base::MATCH_BUCKET
-      expect(Regexp.last_match(1)).to(eq('products'))
+      "products" =~ AssetCloud::Base::MATCH_BUCKET
+      expect(Regexp.last_match(1)).to(eq("products"))
     end
   end
 end

data/spec/blackhole_bucket_spec.rb

@@ -1,42 +1,43 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 class BlackholeCloud < AssetCloud::Base
   bucket AssetCloud::BlackholeBucket
 end
 
 describe BlackholeCloud do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before do
-    @fs = BlackholeCloud.new(directory, 'http://assets/files')
+    @fs = BlackholeCloud.new(directory, "http://assets/files")
   end
 
   it "should allow access to files using the [] operator" do
-    @fs['tmp/image.jpg']
+    @fs["tmp/image.jpg"]
   end
 
   it "should return nil for non existent files" do
-    expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
+    expect(@fs["tmp/image.jpg"].exist?).to(eq(false))
   end
 
   it "should still return nil, even if you wrote something there" do
-    @fs['tmp/image.jpg'] = 'test'
-    expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
+    @fs["tmp/image.jpg"] = "test"
+    expect(@fs["tmp/image.jpg"].exist?).to(eq(false))
   end
 
   describe "when using a sub path" do
     it "should allow access to files using the [] operator" do
-      @fs['tmp/image.jpg']
+      @fs["tmp/image.jpg"]
     end
 
     it "should return nil for non existent files" do
-      expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
+      expect(@fs["tmp/image.jpg"].exist?).to(eq(false))
     end
 
     it "should still return nil, even if you wrote something there" do
-      @fs['tmp/image.jpg'] = 'test'
-      expect(@fs['tmp/image.jpg'].exist?).to(eq(false))
+      @fs["tmp/image.jpg"] = "test"
+      expect(@fs["tmp/image.jpg"].exist?).to(eq(false))
     end
   end
 end

data/spec/bucket_chain_spec.rb

@@ -1,93 +1,98 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
-class ChainedCloud < AssetCloud::Base
-  bucket :stuff, AssetCloud::BucketChain.chain(AssetCloud::MemoryBucket,
-                                                AssetCloud::MemoryBucket,
-                                                AssetCloud::FileSystemBucket)
+require "spec_helper"
 
-  bucket :versioned_stuff, AssetCloud::BucketChain.chain(AssetCloud::FileSystemBucket,
-                                                          AssetCloud::VersionedMemoryBucket,
-                                                          AssetCloud::MemoryBucket)
+class ChainedCloud < AssetCloud::Base
+  bucket :stuff, AssetCloud::BucketChain.chain(
+    AssetCloud::MemoryBucket,
+    AssetCloud::MemoryBucket,
+    AssetCloud::FileSystemBucket,
+  )
+
+  bucket :versioned_stuff, AssetCloud::BucketChain.chain(
+    AssetCloud::FileSystemBucket,
+    AssetCloud::VersionedMemoryBucket,
+    AssetCloud::MemoryBucket,
+  )
 end
 
 describe AssetCloud::BucketChain do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before(:each) do
-    @cloud = ChainedCloud.new(directory, 'http://assets/files')
+    @cloud = ChainedCloud.new(directory, "http://assets/files")
     @bucket_chain = @cloud.buckets[:stuff]
     @chained_buckets = @bucket_chain.chained_buckets
-    @chained_buckets.each { |b| b.ls('stuff').each(&:delete) }
+    @chained_buckets.each { |b| b.ls("stuff").each(&:delete) }
 
     @versioned_stuff = @cloud.buckets[:versioned_stuff]
   end
 
   describe ".chain" do
-    it 'should take multiple Bucket classes and return a new Bucket class' do
+    it "should take multiple Bucket classes and return a new Bucket class" do
       expect(@bucket_chain).to(be_a_kind_of(AssetCloud::BucketChain))
     end
   end
 
   describe "#write" do
-    it 'should write to each sub-bucket when everything is kosher and return the result of the first write' do
+    it "should write to each sub-bucket when everything is kosher and return the result of the first write" do
       @chained_buckets.each do |bucket|
-        expect(bucket).to(receive(:write).with('stuff/foo', 'successful creation').and_return('successful creation'))
+        expect(bucket).to(receive(:write).with("stuff/foo", "successful creation").and_return("successful creation"))
       end
 
-      expect(@bucket_chain.write('stuff/foo', 'successful creation')).to(eq('successful creation'))
+      expect(@bucket_chain.write("stuff/foo", "successful creation")).to(eq("successful creation"))
     end
-    it 'should roll back creation-writes and re-raise an error when a bucket raises one' do
-      expect(@chained_buckets.last).to(receive(:write).with('stuff/foo', 'unsuccessful creation').and_raise('hell'))
+    it "should roll back creation-writes and re-raise an error when a bucket raises one" do
+      expect(@chained_buckets.last).to(receive(:write).with("stuff/foo", "unsuccessful creation").and_raise("hell"))
       @chained_buckets[0..-2].each do |bucket|
-        expect(bucket).to(receive(:write).with('stuff/foo', 'unsuccessful creation').and_return(true))
-        expect(bucket).to(receive(:delete).with('stuff/foo').and_return(true))
+        expect(bucket).to(receive(:write).with("stuff/foo", "unsuccessful creation").and_return(true))
+        expect(bucket).to(receive(:delete).with("stuff/foo").and_return(true))
       end
 
-      expect { @bucket_chain.write('stuff/foo', 'unsuccessful creation') }.to(raise_error(RuntimeError))
+      expect { @bucket_chain.write("stuff/foo", "unsuccessful creation") }.to(raise_error(RuntimeError))
     end
-    it 'should roll back update-writes and re-raise an error when a bucket raises one' do
-      @bucket_chain.write('stuff/foo', "original value")
+    it "should roll back update-writes and re-raise an error when a bucket raises one" do
+      @bucket_chain.write("stuff/foo", "original value")
 
-      expect(@chained_buckets.last).to(receive(:write).with('stuff/foo', 'new value').and_raise('hell'))
+      expect(@chained_buckets.last).to(receive(:write).with("stuff/foo", "new value").and_raise("hell"))
 
-      expect { @bucket_chain.write('stuff/foo', 'new value') }.to(raise_error(RuntimeError))
+      expect { @bucket_chain.write("stuff/foo", "new value") }.to(raise_error(RuntimeError))
       @chained_buckets.each do |bucket|
-        expect(bucket.read('stuff/foo')).to(eq('original value'))
+        expect(bucket.read("stuff/foo")).to(eq("original value"))
       end
     end
   end
 
   describe "#delete" do
-    it 'should delete from each sub-bucket when everything is kosher' do
-      @bucket_chain.write('stuff/foo', "successful deletion comin' up")
+    it "should delete from each sub-bucket when everything is kosher" do
+      @bucket_chain.write("stuff/foo", "successful deletion comin' up")
 
       @chained_buckets.each do |bucket|
-        expect(bucket).to(receive(:delete).with('stuff/foo').and_return(true))
+        expect(bucket).to(receive(:delete).with("stuff/foo").and_return(true))
       end
 
-      @bucket_chain.delete('stuff/foo')
+      @bucket_chain.delete("stuff/foo")
     end
-    it 'should roll back deletions and re-raise an error when a bucket raises one' do
-      @bucket_chain.write('stuff/foo', "this deletion will fail")
+    it "should roll back deletions and re-raise an error when a bucket raises one" do
+      @bucket_chain.write("stuff/foo", "this deletion will fail")
 
-      expect(@chained_buckets.last).to(receive(:delete).with('stuff/foo').and_raise('hell'))
+      expect(@chained_buckets.last).to(receive(:delete).with("stuff/foo").and_raise("hell"))
       @chained_buckets[0..-2].each do |bucket|
-        expect(bucket).to(receive(:delete).with('stuff/foo').and_return(true))
-        expect(bucket).to(receive(:write).with('stuff/foo', 'this deletion will fail').and_return(true))
+        expect(bucket).to(receive(:delete).with("stuff/foo").and_return(true))
+        expect(bucket).to(receive(:write).with("stuff/foo", "this deletion will fail").and_return(true))
       end
 
-      expect { @bucket_chain.delete('stuff/foo') }.to(raise_error(RuntimeError))
+      expect { @bucket_chain.delete("stuff/foo") }.to(raise_error(RuntimeError))
     end
   end
 
   describe "#read" do
-    it 'should read from only the first available sub-bucket' do
-      expect(@chained_buckets[0]).to(receive(:read).with('stuff/foo').and_raise(NotImplementedError))
+    it "should read from only the first available sub-bucket" do
+      expect(@chained_buckets[0]).to(receive(:read).with("stuff/foo").and_raise(NotImplementedError))
       expect(@chained_buckets[0]).to(receive(:ls).with(nil).and_raise(NoMethodError))
       expect(@chained_buckets[0]).to(receive(:stat).and_return(:metadata))
 
-      expect(@chained_buckets[1]).to(receive(:read).with('stuff/foo').and_return('bar'))
+      expect(@chained_buckets[1]).to(receive(:read).with("stuff/foo").and_return("bar"))
       expect(@chained_buckets[1]).to(receive(:ls).with(nil).and_return(:some_assets))
       expect(@chained_buckets[1]).not_to(receive(:stat))
 
@@ -97,59 +102,59 @@ describe AssetCloud::BucketChain do
         expect(bucket).not_to(receive(:stat))
       end
 
-      expect(@bucket_chain.read('stuff/foo')).to(eq('bar'))
+      expect(@bucket_chain.read("stuff/foo")).to(eq("bar"))
       expect(@bucket_chain.ls).to(eq(:some_assets))
       expect(@bucket_chain.stat).to(eq(:metadata))
     end
   end
 
   describe "#read_version" do
-    it 'should read from only the first available sub-bucket' do
+    it "should read from only the first available sub-bucket" do
       buckets = @versioned_stuff.chained_buckets
 
-      expect(buckets[1]).to(receive(:read_version).with('stuff/foo', 3).and_return('bar'))
+      expect(buckets[1]).to(receive(:read_version).with("stuff/foo", 3).and_return("bar"))
       expect(buckets.last).not_to(receive(:read_version))
 
-      expect(@versioned_stuff.read_version('stuff/foo', 3)).to(eq('bar'))
+      expect(@versioned_stuff.read_version("stuff/foo", 3)).to(eq("bar"))
     end
   end
 
   describe "#versions" do
-    it 'should read from only the first available sub-bucket' do
+    it "should read from only the first available sub-bucket" do
       buckets = @versioned_stuff.chained_buckets
 
-      expect(buckets[1]).to(receive(:versions).with('versioned_stuff/foo').and_return([1, 2, 3]))
+      expect(buckets[1]).to(receive(:versions).with("versioned_stuff/foo").and_return([1, 2, 3]))
       expect(buckets.last).not_to(receive(:versions))
 
-      expect(@versioned_stuff.versions('versioned_stuff/foo')).to(eq([1, 2, 3]))
+      expect(@versioned_stuff.versions("versioned_stuff/foo")).to(eq([1, 2, 3]))
     end
   end
 
   describe "with versioned buckets" do
-    it 'should store and retrieve versions seamlessly' do
-      %w{one two three}.each do |content|
-        @cloud['versioned_stuff/foo'] = content
+    it "should store and retrieve versions seamlessly" do
+      ["one", "two", "three"].each do |content|
+        @cloud["versioned_stuff/foo"] = content
       end
-      asset = @cloud['versioned_stuff/foo']
-      expect(asset.value).to(eq('three'))
-      expect(asset.rollback(1).value).to(eq('one'))
+      asset = @cloud["versioned_stuff/foo"]
+      expect(asset.value).to(eq("three"))
+      expect(asset.rollback(1).value).to(eq("one"))
       expect(asset.versions).to(eq([1, 2, 3]))
-      asset.value = 'four'
+      asset.value = "four"
       asset.store
       expect(asset.versions).to(eq([1, 2, 3, 4]))
     end
   end
 
-  describe '#respond_to?' do
-    it 'should return true if any chained buckets respond to the given method' do
+  describe "#respond_to?" do
+    it "should return true if any chained buckets respond to the given method" do
       expect(@bucket_chain.respond_to?(:foo)).to(eq(false))
       expect(@chained_buckets[1]).to(receive(:respond_to?).with(:bar).and_return(true))
       expect(@bucket_chain.respond_to?(:bar)).to(eq(true))
     end
   end
 
-  describe '#method_missing' do
-    it 'should try each bucket' do
+  describe "#method_missing" do
+    it "should try each bucket" do
       expect(@chained_buckets[1]).to(receive(:buzz).and_return(true))
       expect(@chained_buckets[2]).not_to(receive(:buzz))
       expect(@bucket_chain.buzz).to(eq(true))

data/spec/bucket_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe AssetCloud::Bucket do
   before do
@@ -8,19 +9,19 @@ describe AssetCloud::Bucket do
 
   describe "operations not supported" do
     it "#ls not supported" do
-      expect { @bucket.ls('foo') }.to(raise_error(NotImplementedError))
+      expect { @bucket.ls("foo") }.to(raise_error(NotImplementedError))
     end
 
     it "#read(key) not supported" do
-      expect { @bucket.read('foo') }.to(raise_error(NotImplementedError))
+      expect { @bucket.read("foo") }.to(raise_error(NotImplementedError))
     end
 
     it "#write(key, data) not supported" do
-      expect { @bucket.write('foo', 'bar') }.to(raise_error(NotImplementedError))
+      expect { @bucket.write("foo", "bar") }.to(raise_error(NotImplementedError))
     end
 
     it "#delete(key) not supported" do
-      expect { @bucket.delete('foo') }.to(raise_error(NotImplementedError))
+      expect { @bucket.delete("foo") }.to(raise_error(NotImplementedError))
     end
   end
 end