asset_cloud 2.7.1 → 2.7.3

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

data/spec/callbacks_spec.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
+require "spec_helper"
 
 class AfterStoreCallback
-  def self.after_store(*args); end
+  class << self
+    def after_store(*args); end
+  end
 end
 
 class CallbackAsset < AssetCloud::Asset
@@ -14,22 +16,28 @@ class CallbackAsset < AssetCloud::Asset
   after_validate :add_spice
   validate :valid_value
 
+  before_validate(&:proc_executed_before)
+  after_validate(&:proc_executed_after)
+
   after_store ::AfterStoreCallback
 
+  def proc_executed_before(*args); end
+  def proc_executed_after(*args); end
+
   private
 
   def callback_before_delete(*args); end
 
   def make_value_valid
-    self.value = 'valid'
+    self.value = "valid"
   end
 
   def add_spice
-    self.value += ' spice'
+    self.value += " spice"
   end
 
   def valid_value
-    add_error('value is not "valid"') unless value == 'valid'
+    add_error('value is not "valid"') unless value == "valid"
   end
 end
 
@@ -59,89 +67,107 @@ class MethodRecordingCloud < AssetCloud::Base
   before_write :callback_before_write
   after_write :callback_before_write
 
-  def method_missing(method, *_args)
-    @run_callbacks << method.to_sym
+  def callback_before_write(*)
+    @run_callbacks << __method__
   end
 end
 
 describe CallbackCloud do
   before do
-    @fs = CallbackCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
-    @fs.write('tmp/file.txt', 'foo')
+    @fs = CallbackCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
+    @fs.write("tmp/file.txt", "foo")
   end
 
   it "should invoke callbacks after store" do
-    expect(@fs).to(receive(:callback_before_write).with('tmp/file.txt', 'text').and_return(true))
-    expect(@fs).to(receive(:callback_after_write).with('tmp/file.txt', 'text').and_return(true))
+    expect(@fs).to(receive(:callback_before_write).with("tmp/file.txt", "text").and_return(true))
+    expect(@fs).to(receive(:callback_after_write).with("tmp/file.txt", "text").and_return(true))
 
-    expect(@fs.write('tmp/file.txt', 'text')).to(eq(true))
-    expect(@fs.read('tmp/file.txt')).to(eq('text'))
+    expect(@fs.write("tmp/file.txt", "text")).to(eq(true))
+    expect(@fs.read("tmp/file.txt")).to(eq("text"))
   end
 
   it "should invoke callbacks after delete" do
-    expect(@fs).to(receive(:callback_before_delete).with('tmp/file.txt').and_return(true))
-    expect(@fs).to(receive(:callback_after_delete).with('tmp/file.txt').and_return(true))
+    expect(@fs).to(receive(:callback_before_delete).with("tmp/file.txt").and_return(true))
+    expect(@fs).to(receive(:callback_after_delete).with("tmp/file.txt").and_return(true))
 
-    expect(@fs.delete('tmp/file.txt')).to(eq('foo'))
+    expect(@fs.delete("tmp/file.txt")).to(eq("foo"))
   end
 
   it "should not invoke other callbacks when a before_ filter returns false" do
     expect(@fs).to(receive(:callback_before_delete)
-      .with('tmp/file.txt')
+      .with("tmp/file.txt")
       .and_return(false))
     expect(@fs).not_to(receive(:callback_after_delete))
 
-    expect(@fs.delete('tmp/file.txt')).to(eq(nil))
+    expect(@fs.delete("tmp/file.txt")).to(eq(nil))
   end
 
   it "should invoke callbacks even when constructing a new asset" do
-    expect(@fs).to(receive(:callback_before_write).with('tmp/file.txt', 'hello').and_return(true))
-    expect(@fs).to(receive(:callback_after_write).with('tmp/file.txt', 'hello').and_return(true))
+    expect(@fs).to(receive(:callback_before_write).with("tmp/file.txt", "hello").and_return(true))
+    expect(@fs).to(receive(:callback_after_write).with("tmp/file.txt", "hello").and_return(true))
 
-    asset = @fs.build('tmp/file.txt')
-    asset.value = 'hello'
+    asset = @fs.build("tmp/file.txt")
+    asset.value = "hello"
     expect(asset.store).to(eq(true))
   end
 end
 
 describe MethodRecordingCloud do
   before do
-    @fs = MethodRecordingCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
+    @fs = MethodRecordingCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
     @fs.run_callbacks = []
   end
 
-  it 'should record event when invoked' do
-    @fs.write('tmp/file.txt', 'random data')
+  it "should record event when invoked" do
+    @fs.write("tmp/file.txt", "random data")
     expect(@fs.run_callbacks).to(eq([:callback_before_write, :callback_before_write]))
   end
 
-  it 'should record event when assignment operator is used' do
-    @fs['tmp/file.txt'] = 'random data'
+  it "should record event when assignment operator is used" do
+    @fs["tmp/file.txt"] = "random data"
     expect(@fs.run_callbacks).to(eq([:callback_before_write, :callback_before_write]))
   end
 end
 
 describe CallbackAsset do
   before(:each) do
-    @fs = BasicCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
-    @fs.write('callback_assets/foo', 'bar')
-    @asset = @fs.asset_at('callback_assets/foo')
+    @fs = BasicCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
+    @fs.write("callback_assets/foo", "bar")
+    @asset = @fs.asset_at("callback_assets/foo")
   end
 
   it "should run before_validate, then validate, then after validate, then before_store, then store" do
     expect(@asset).to(receive(:callback_before_store).and_return(true))
     expect(@asset).not_to(receive(:callback_after_delete))
 
-    @asset.value = 'foo'
+    @asset.value = "foo"
+    expect(@asset.store).to(eq(true))
+    expect(@asset.value).to(eq("valid spice"))
+  end
+
+  it "should run before_validate with procs" do
+    expect(@asset).to(receive(:callback_before_store).and_return(true))
+    expect(@asset).to(receive(:proc_executed_before))
+
+    @asset.value = "foo"
+
+    expect(@asset.store).to(eq(true))
+  end
+
+  it "should run after_validate with procs" do
+    expect(@asset).to(receive(:callback_before_store).and_return(true))
+    expect(@asset).to(receive(:proc_executed_after))
+
+    @asset.value = "foo"
+
     expect(@asset.store).to(eq(true))
-    expect(@asset.value).to(eq('valid spice'))
   end
 
   it "should run its after_delete callback after delete is called" do
     expect(@asset).not_to(receive(:callback_before_store))
     expect(@asset).to(receive(:callback_after_delete).and_return(true))
 
-    expect(@asset.delete).to(eq('bar'))
+    expect(@asset.delete).to(eq("bar"))
   end
 
   it "not invoke other callbacks when a before_ filter returns false" do
@@ -152,13 +178,13 @@ describe CallbackAsset do
   end
 
   it "should invoke after_store callback defined in separate class" do
-    local_fs = BasicCloud.new(File.dirname(__FILE__) + '/files', 'http://assets/')
-    local_fs.write('callback_assets/foo', 'bar')
-    local_asset = local_fs.asset_at('callback_assets/foo')
-    
+    local_fs = BasicCloud.new(File.dirname(__FILE__) + "/files", "http://assets/")
+    local_fs.write("callback_assets/foo", "bar")
+    local_asset = local_fs.asset_at("callback_assets/foo")
+
     expect(local_asset).to(receive(:callback_before_store).and_return(true))
-    expect(::AfterStoreCallback).to(receive(:after_store))
-    
+    expect(AfterStoreCallback).to(receive(:after_store))
+
     expect(local_asset.store).to(eq(true))
   end
 end

data/spec/file_system_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'fileutils'
+
+require "spec_helper"
+require "fileutils"
 
 class FileSystemCloud < AssetCloud::Base
   bucket AssetCloud::InvalidBucket
@@ -9,64 +10,64 @@ class FileSystemCloud < AssetCloud::Base
 end
 
 describe FileSystemCloud do
-  directory = File.dirname(__FILE__) + '/files'
+  directory = File.dirname(__FILE__) + "/files"
 
   before do
-    @fs = FileSystemCloud.new(directory, 'http://assets/files')
-    FileUtils.mkdir_p(directory + '/tmp')
+    @fs = FileSystemCloud.new(directory, "http://assets/files")
+    FileUtils.mkdir_p(directory + "/tmp")
   end
 
   after do
-    FileUtils.rm_rf(directory + '/tmp')
+    FileUtils.rm_rf(directory + "/tmp")
   end
 
   it "should use invalid bucket for random directories" do
-    expect(@fs.bucket_for('does-not-exist/file.txt')).to(be_an_instance_of(AssetCloud::InvalidBucket))
+    expect(@fs.bucket_for("does-not-exist/file.txt")).to(be_an_instance_of(AssetCloud::InvalidBucket))
   end
 
   it "should use filesystem bucket for products/ and tmp/  directories" do
-    expect(@fs.bucket_for('products/file.txt')).to(be_an_instance_of(AssetCloud::FileSystemBucket))
-    expect(@fs.bucket_for('tmp/file.txt')).to(be_an_instance_of(AssetCloud::FileSystemBucket))
+    expect(@fs.bucket_for("products/file.txt")).to(be_an_instance_of(AssetCloud::FileSystemBucket))
+    expect(@fs.bucket_for("tmp/file.txt")).to(be_an_instance_of(AssetCloud::FileSystemBucket))
   end
 
   it "should return Asset for existing files" do
-    expect(@fs['products/key.txt'].exist?).to(eq(true))
-    expect(@fs['products/key.txt']).to(be_an_instance_of(AssetCloud::Asset))
+    expect(@fs["products/key.txt"].exist?).to(eq(true))
+    expect(@fs["products/key.txt"]).to(be_an_instance_of(AssetCloud::Asset))
   end
 
   it "should be able to test if a file exists or not" do
-    expect(@fs.stat('products/key.txt').exist?).to(eq(true))
-    expect(@fs.stat('products/key2.txt').exist?).to(eq(false))
+    expect(@fs.stat("products/key.txt").exist?).to(eq(true))
+    expect(@fs.stat("products/key2.txt").exist?).to(eq(false))
   end
 
   it "should be able to list files" do
-    expect(@fs.ls('products').collect(&:key)).to(eq(['products/key.txt']))
+    expect(@fs.ls("products").collect(&:key)).to(eq(["products/key.txt"]))
   end
 
-  describe 'when modifying file system' do
+  describe "when modifying file system" do
     it "should call write after storing an asset" do
-      expect(@fs.buckets[:tmp]).to(receive(:write).with('tmp/new_file.test', 'hello world').and_return(true))
+      expect(@fs.buckets[:tmp]).to(receive(:write).with("tmp/new_file.test", "hello world").and_return(true))
 
-      @fs.build('tmp/new_file.test', 'hello world').store
+      @fs.build("tmp/new_file.test", "hello world").store
     end
 
     it "should be able to create new files" do
-      @fs.build('tmp/new_file.test', 'hello world').store
+      @fs.build("tmp/new_file.test", "hello world").store
 
-      expect(@fs.stat('tmp/new_file.test').exist).to(eq(true))
+      expect(@fs.stat("tmp/new_file.test").exist).to(eq(true))
     end
 
     it "should be able to create new files with simple assignment" do
-      @fs['tmp/new_file.test'] = 'hello world'
+      @fs["tmp/new_file.test"] = "hello world"
 
-      expect(@fs.stat('tmp/new_file.test').exist).to(eq(true))
+      expect(@fs.stat("tmp/new_file.test").exist).to(eq(true))
     end
 
     it "should create directories as needed" do
-      @fs.build('tmp/new_file.test', 'hello world').store
+      @fs.build("tmp/new_file.test", "hello world").store
 
-      expect(@fs['tmp/new_file.test'].exist?).to(eq(true))
-      expect(@fs['tmp/new_file.test'].value).to(eq('hello world'))
+      expect(@fs["tmp/new_file.test"].exist?).to(eq(true))
+      expect(@fs["tmp/new_file.test"].value).to(eq("hello world"))
     end
   end
 end

data/spec/find_free_key_spec.rb

@@ -1,44 +1,43 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 class FindFreeKey
   extend AssetCloud::FreeKeyLocator
 end
 
-describe "FreeFilenameLocator", 'when asked to return a free key such as the one passed in' do
+describe "FreeFilenameLocator", "when asked to return a free key such as the one passed in" do
   it "should simply return the key if it happens to be free" do
-    expect(FindFreeKey).to(receive(:exist?).with('free.txt').and_return(false))
+    expect(FindFreeKey).to(receive(:exist?).with("free.txt").and_return(false))
 
-    expect(FindFreeKey.find_free_key_like('free.txt')).to(eq('free.txt'))
+    expect(FindFreeKey.find_free_key_like("free.txt")).to(eq("free.txt"))
   end
 
   it "should append a UUID to the key before the extension if key is taken" do
-    allow(SecureRandom).to(receive(:uuid).and_return('moo'))
-    expect(FindFreeKey).to(receive(:exist?).with('free.txt').and_return(true))
-    expect(FindFreeKey).to(receive(:exist?).with('free_moo.txt').and_return(false))
+    allow(SecureRandom).to(receive(:uuid).and_return("moo"))
+    expect(FindFreeKey).to(receive(:exist?).with("free.txt").and_return(true))
+    expect(FindFreeKey).to(receive(:exist?).with("free_moo.txt").and_return(false))
 
-    expect(FindFreeKey.find_free_key_like('free.txt')).to(eq('free_moo.txt'))
+    expect(FindFreeKey.find_free_key_like("free.txt")).to(eq("free_moo.txt"))
   end
 
   it "should not strip any directory information from the key" do
-    allow(SecureRandom).to(receive(:uuid).and_return('moo'))
-    expect(FindFreeKey).to(receive(:exist?).with('products/images/image.gif').and_return(true))
-    expect(FindFreeKey).to(receive(:exist?).with('products/images/image_moo.gif').and_return(false))
+    allow(SecureRandom).to(receive(:uuid).and_return("moo"))
+    expect(FindFreeKey).to(receive(:exist?).with("products/images/image.gif").and_return(true))
+    expect(FindFreeKey).to(receive(:exist?).with("products/images/image_moo.gif").and_return(false))
 
-    expect(FindFreeKey.find_free_key_like('products/images/image.gif')).to(eq('products/images/image_moo.gif'))
+    expect(FindFreeKey.find_free_key_like("products/images/image.gif")).to(eq("products/images/image_moo.gif"))
   end
 
   it "should raise an exception if the randomly chosen value (after 10 attempts) is also taken" do
     allow(FindFreeKey).to(receive(:exist?).and_return(true))
-    expect { FindFreeKey.find_free_key_like('free.txt') }.to(raise_error(StandardError))
+    expect { FindFreeKey.find_free_key_like("free.txt") }.to(raise_error(StandardError))
   end
 
   it "should append a UUID to the key before the extensions if the force_uuid option is passed" do
-    expect(FindFreeKey).to(receive(:exist?).with('free.txt').and_return(false))
-    expect(FindFreeKey).to(receive(:exist?).with('free_as-in-beer.txt').and_return(false))
-    allow(SecureRandom).to(receive(:uuid).and_return('as-in-beer'))
+    expect(FindFreeKey).to(receive(:exist?).with("free_as-in-beer.txt").and_return(false))
+    allow(SecureRandom).to(receive(:uuid).and_return("as-in-beer"))
 
-    expect(FindFreeKey.find_free_key_like('free.txt', force_uuid: true)).to(eq('free_as-in-beer.txt'))
+    expect(FindFreeKey.find_free_key_like("free.txt", force_uuid: true)).to(eq("free_as-in-beer.txt"))
   end
 end