asset_cloud 2.7.1 → 2.7.3

data/spec/asset_spec.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe "Asset" do
   include AssetCloud
 
   before do
-    @cloud = double('Cloud', asset_extension_classes_for_bucket: [])
+    @cloud = double("Cloud", asset_extension_classes_for_bucket: [])
   end
 
   describe "when first created (without a value)" do
@@ -18,7 +19,7 @@ describe "Asset" do
     end
 
     it "should have a key" do
-      expect(@asset.key).to(eq('products/key.txt'))
+      expect(@asset.key).to(eq("products/key.txt"))
     end
 
     it "should have a value of nil" do
@@ -26,23 +27,23 @@ describe "Asset" do
     end
 
     it "should have a basename" do
-      expect(@asset.basename).to(eq('key.txt'))
+      expect(@asset.basename).to(eq("key.txt"))
     end
 
     it "should have a basename without ext (if required)" do
-      expect(@asset.basename_without_ext).to(eq('key'))
+      expect(@asset.basename_without_ext).to(eq("key"))
     end
 
     it "should have an ext" do
-      expect(@asset.extname).to(eq('.txt'))
+      expect(@asset.extname).to(eq(".txt"))
     end
 
     it "should have a relative_key_without_ext" do
-      expect(@asset.relative_key_without_ext).to(eq('key'))
+      expect(@asset.relative_key_without_ext).to(eq("key"))
     end
 
     it "should have a bucket_name" do
-      expect(@asset.bucket_name).to(eq('products'))
+      expect(@asset.bucket_name).to(eq("products"))
     end
 
     it "should have a bucket" do
@@ -51,9 +52,9 @@ describe "Asset" do
     end
 
     it "should store data to the bucket" do
-      expect(@cloud).to(receive(:write).with("products/key.txt", 'value'))
+      expect(@cloud).to(receive(:write).with("products/key.txt", "value"))
 
-      @asset.value = 'value'
+      @asset.value = "value"
       @asset.store
     end
 
@@ -82,17 +83,17 @@ describe "Asset" do
     end
 
     it "should have a relative_key_without_ext" do
-      expect(@asset.relative_key_without_ext).to(eq('retail/key'))
+      expect(@asset.relative_key_without_ext).to(eq("retail/key"))
     end
 
     it "should have a relative_key" do
-      expect(@asset.relative_key).to(eq('retail/key.txt'))
+      expect(@asset.relative_key).to(eq("retail/key.txt"))
     end
   end
 
   describe "when first created with value" do
     before do
-      @asset = AssetCloud::Asset.new(@cloud, "products/key.txt", 'value')
+      @asset = AssetCloud::Asset.new(@cloud, "products/key.txt", "value")
     end
 
     it "should be return new_asset? => true" do
@@ -100,7 +101,7 @@ describe "Asset" do
     end
 
     it "should have a value of 'value'" do
-      expect(@asset.value).to(eq('value'))
+      expect(@asset.value).to(eq("value"))
     end
 
     it "should return false when asked if it exists because its still a new_asset" do
@@ -110,18 +111,23 @@ describe "Asset" do
     it "should not try to read data from bucket if its a new_asset" do
       expect(@cloud).to(receive(:read).never)
 
-      expect(@asset.value).to(eq('value'))
+      expect(@asset.value).to(eq("value"))
     end
 
     it "should write data to the bucket" do
-      expect(@cloud).to(receive(:write).with("products/key.txt", 'value'))
+      expect(@cloud).to(receive(:write).with("products/key.txt", "value"))
       @asset.store
     end
   end
 
   describe "when fetched from the bucket" do
     before do
-      @asset = AssetCloud::Asset.at(@cloud, "products/key.txt", 'value', AssetCloud::Metadata.new(true, 'value'.size, Time.now, Time.now))
+      @asset = AssetCloud::Asset.at(
+        @cloud,
+        "products/key.txt",
+        "value",
+        AssetCloud::Metadata.new(true, "value".size, Time.now, Time.now),
+      )
     end
 
     it "should be return new_asset? => false" do
@@ -133,7 +139,7 @@ describe "Asset" do
     end
 
     it "should read the value from the bucket" do
-      expect(@asset.value).to(eq('value'))
+      expect(@asset.value).to(eq("value"))
     end
 
     it "should simply ignore calls to delete" do
@@ -143,13 +149,13 @@ describe "Asset" do
     end
 
     it "should ask the bucket to create a full url" do
-      expect(@cloud).to(receive(:url_for).with('products/key.txt', {}).and_return('http://assets/products/key.txt'))
+      expect(@cloud).to(receive(:url_for).with("products/key.txt", {}).and_return("http://assets/products/key.txt"))
 
-      expect(@asset.url).to(eq('http://assets/products/key.txt'))
+      expect(@asset.url).to(eq("http://assets/products/key.txt"))
     end
 
     it "should ask the bucket whether or not it is versioned" do
-      bucket = double('Bucket')
+      bucket = double("Bucket")
       expect(@cloud).to(receive(:buckets).and_return(products: bucket))
       expect(bucket).to(receive(:versioned?).and_return(true))
 

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