asset_cloud 2.5.3 → 2.6.0

data/spec/asset_cloud/metadata_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'asset_cloud/metadata'
+
+module AssetCloud
+  describe Metadata do
+    it "exposes the checksum" do
+      exist = true
+      size = 1
+      created_at = Time.utc(2020, 5, 19, 13, 14, 15)
+      updated_at = Time.utc(2020, 5, 19, 16, 17, 18)
+      value_hash = "abc123"
+      checksum = "def456"
+
+      metadata = Metadata.new(exist, size, created_at, updated_at, value_hash, checksum)
+
+      expect(metadata.checksum).to(eq("def456"))
+    end
+
+    it "defaults the checksum to nil if not provided" do
+      exist = true
+      size = 1
+      created_at = Time.utc(2020, 5, 19, 13, 14, 15)
+      updated_at = Time.utc(2020, 5, 19, 16, 17, 18)
+      value_hash = "abc123"
+
+      metadata = Metadata.new(exist, size, created_at, updated_at, value_hash)
+
+      expect(metadata.checksum).to(be(nil))
+    end
+  end
+end

data/spec/asset_extension_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class NoCatsAsset < AssetCloud::Asset
@@ -5,6 +6,7 @@ class NoCatsAsset < AssetCloud::Asset
   before_store :asset_callback
 
   private
+
   def no_cats
     add_error('no cats allowed!') if value =~ /cat/i
   end
@@ -16,8 +18,9 @@ class CssAssetExtension < AssetCloud::AssetExtension
   validate :valid_css
 
   private
+
   def valid_css
-    add_error "not enough curly brackets!" unless asset.value =~ /\{.*\}/
+    add_error("not enough curly brackets!") unless asset.value =~ /\{.*\}/
   end
 end
 
@@ -32,17 +35,18 @@ class XmlAssetExtension < AssetCloud::AssetExtension
   end
 
   private
+
   def valid_xml
-    add_error "not enough angle brackets!" unless asset.value =~ /\<.*\>/
+    add_error("not enough angle brackets!") unless asset.value =~ /\<.*\>/
   end
 end
 
 class CatsAndDogsCloud < AssetCloud::Base
-  bucket :dog_pound, AssetCloud::MemoryBucket, :asset_class => NoCatsAsset
+  bucket :dog_pound, AssetCloud::MemoryBucket, asset_class: NoCatsAsset
   bucket :cat_pen, AssetCloud::MemoryBucket
 
-  asset_extensions CssAssetExtension, :only => :cat_pen
-  asset_extensions XmlAssetExtension, :except => :cat_pen
+  asset_extensions CssAssetExtension, only: :cat_pen
+  asset_extensions XmlAssetExtension, except: :cat_pen
 end
 
 describe "AssetExtension" do
@@ -55,7 +59,7 @@ describe "AssetExtension" do
   describe "applicability" do
     it "should work" do
       asset = @cloud['cat_pen/cats.xml']
-      XmlAssetExtension.applies_to_asset?(asset).should == true
+      expect(XmlAssetExtension.applies_to_asset?(asset)).to(eq(true))
     end
   end
 
@@ -63,31 +67,31 @@ describe "AssetExtension" do
     it "should be added to assets in the right bucket with the right extension" do
       asset = @cloud['cat_pen/cats.css']
       asset.value = 'foo'
-      asset.store.should == false
-      asset.errors.should == ["not enough curly brackets!"]
+      expect(asset.store).to(eq(false))
+      expect(asset.errors).to(eq(["not enough curly brackets!"]))
     end
 
     it "should not squash existing validations on the asset" do
       asset = @cloud['dog_pound/cats.xml']
       asset.value = 'cats!'
-      asset.store.should == false
-      asset.errors.should == ['no cats allowed!', "not enough angle brackets!"]
+      expect(asset.store).to(eq(false))
+      expect(asset.errors).to(eq(['no cats allowed!', "not enough angle brackets!"]))
     end
 
     it "should not apply to non-matching assets or those in exempted buckets" do
       asset = @cloud['cat_pen/cats.xml']
       asset.value = "xml"
-      asset.store.should == true
+      expect(asset.store).to(eq(true))
     end
   end
 
   describe "callbacks" do
     it "should run alongside the asset's callbacks" do
       asset = @cloud['dog_pound/dogs.xml']
-      asset.should_receive(:asset_callback)
-      asset.extensions.first.should_receive(:xml_callback)
+      expect(asset).to(receive(:asset_callback))
+      expect(asset.extensions.first).to(receive(:xml_callback))
       asset.value = '<dogs/>'
-      asset.store.should == true
+      expect(asset.store).to(eq(true))
     end
   end
 
@@ -96,7 +100,7 @@ describe "AssetExtension" do
       asset = @cloud['dog_pound/dogs.xml']
       asset.value = 'dogs'
       asset.turn_into_xml
-      asset.value.should == '<xml>dogs</xml>'
+      expect(asset.value).to(eq('<xml>dogs</xml>'))
     end
 
     it "does not swallow NotImplementedError" do
@@ -106,9 +110,8 @@ describe "AssetExtension" do
 
       asset = @cloud['dog_pound/dogs.xml']
 
-      expect(asset).to respond_to(:my_unimplemented_extension)
-      expect { asset.my_unimplemented_extension }.to raise_error(NotImplementedError)
+      expect(asset).to(respond_to(:my_unimplemented_extension))
+      expect { asset.my_unimplemented_extension }.to(raise_error(NotImplementedError))
     end
   end
-
 end

data/spec/asset_spec.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 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
@@ -13,116 +14,109 @@ describe "Asset" do
     end
 
     it "should be return new_asset? => true" do
-      @asset.new_asset?.should == true
+      expect(@asset.new_asset?).to(eq(true))
     end
 
     it "should have a key" do
-      @asset.key.should == 'products/key.txt'
+      expect(@asset.key).to(eq('products/key.txt'))
     end
 
     it "should have a value of nil" do
-
-      @asset.value.should == nil
+      expect(@asset.value).to(eq(nil))
     end
 
     it "should have a basename" do
-      @asset.basename.should == 'key.txt'
+      expect(@asset.basename).to(eq('key.txt'))
     end
 
     it "should have a basename without ext (if required)" do
-      @asset.basename_without_ext.should == 'key'
+      expect(@asset.basename_without_ext).to(eq('key'))
     end
 
     it "should have an ext" do
-      @asset.extname.should == '.txt'
+      expect(@asset.extname).to(eq('.txt'))
     end
 
     it "should have a relative_key_without_ext" do
-      @asset.relative_key_without_ext.should == 'key'
+      expect(@asset.relative_key_without_ext).to(eq('key'))
     end
 
     it "should have a bucket_name" do
-      @asset.bucket_name.should == 'products'
+      expect(@asset.bucket_name).to(eq('products'))
     end
 
     it "should have a bucket" do
-      @cloud.should_receive(:buckets).and_return(:products => :products_bucket)
-      @asset.bucket.should == :products_bucket
+      expect(@cloud).to(receive(:buckets).and_return(products: :products_bucket))
+      expect(@asset.bucket).to(eq(:products_bucket))
     end
 
     it "should store data to the bucket" do
-      @cloud.should_receive(:write).with("products/key.txt", 'value')
+      expect(@cloud).to(receive(:write).with("products/key.txt", 'value'))
 
       @asset.value = 'value'
       @asset.store
     end
 
     it "should not try to store data when it's value is nil" do
-      @cloud.should_receive(:write).never
+      expect(@cloud).to(receive(:write).never)
 
       @asset.store
     end
 
     it "should not try to read data from bucket if its a new_asset" do
-      @cloud.should_receive(:read).never
+      expect(@cloud).to(receive(:read).never)
 
-      @asset.value.should == nil
+      expect(@asset.value).to(eq(nil))
     end
 
     it "should simply ignore calls to delete" do
-      @cloud.should_receive(:delete).never
+      expect(@cloud).to(receive(:delete).never)
 
       @asset.delete
     end
-
   end
 
-
   describe "when first created (without a value) with subdirectory" do
     before do
       @asset = AssetCloud::Asset.new(@cloud, "products/retail/key.txt")
     end
 
     it "should have a relative_key_without_ext" do
-      @asset.relative_key_without_ext.should == 'retail/key'
+      expect(@asset.relative_key_without_ext).to(eq('retail/key'))
     end
 
     it "should have a relative_key" do
-      @asset.relative_key.should == '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')
     end
 
     it "should be return new_asset? => true" do
-      @asset.new_asset?.should == true
+      expect(@asset.new_asset?).to(eq(true))
     end
 
-
     it "should have a value of 'value'" do
-      @asset.value.should == 'value'
+      expect(@asset.value).to(eq('value'))
     end
 
     it "should return false when asked if it exists because its still a new_asset" do
-      @asset.exist?.should == false
+      expect(@asset.exist?).to(eq(false))
     end
 
-
     it "should not try to read data from bucket if its a new_asset" do
-      @cloud.should_receive(:read).never
+      expect(@cloud).to(receive(:read).never)
 
-      @asset.value.should == 'value'
+      expect(@asset.value).to(eq('value'))
     end
 
     it "should write data to the bucket" do
-      @cloud.should_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
@@ -131,45 +125,42 @@ describe "Asset" do
     end
 
     it "should be return new_asset? => false" do
-      @asset.new_asset?.should == false
+      expect(@asset.new_asset?).to(eq(false))
     end
 
     it "should indicate that it exists" do
-
-      @asset.exist?.should == true
+      expect(@asset.exist?).to(eq(true))
     end
 
-
     it "should read the value from the bucket" do
-      @asset.value.should == 'value'
+      expect(@asset.value).to(eq('value'))
     end
 
-
     it "should simply ignore calls to delete" do
-      @cloud.should_receive(:delete).and_return(true)
+      expect(@cloud).to(receive(:delete).and_return(true))
 
       @asset.delete
     end
 
     it "should ask the bucket to create a full url" do
-      @cloud.should_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'))
 
-      @asset.url.should == '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')
-      @cloud.should_receive(:buckets).and_return(:products => bucket)
-      bucket.should_receive(:versioned?).and_return(true)
+      expect(@cloud).to(receive(:buckets).and_return(products: bucket))
+      expect(bucket).to(receive(:versioned?).and_return(true))
 
-      @asset.versioned?.should == true
+      expect(@asset.versioned?).to(eq(true))
     end
 
     it "should validate its key" do
       asset = AssetCloud::Asset.new(@cloud, "products/foo, bar.txt", "data")
-      asset.store.should == false
-      asset.errors.size.should == 1
-      asset.errors.first.should =~ /illegal characters/
+      expect(asset.store).to(eq(false))
+      expect(asset.errors.size).to(eq(1))
+      expect(asset.errors.first).to(match(/illegal characters/))
     end
   end
 
@@ -183,14 +174,14 @@ describe "Asset" do
       it "is equal if cloud and key of both assets are equal" do
         other_asset = AssetCloud::Asset.new(@cloud, @key)
 
-        expect(@asset == other_asset).to eq(true)
+        expect(@asset == other_asset).to(eq(true))
       end
 
       it "is not equal if key of both assets are not equal" do
         other_key = "products/other_key.txt"
         other_asset = AssetCloud::Asset.new(@cloud, other_key)
 
-        expect(@asset == other_asset).to eq(false)
+        expect(@asset == other_asset).to(eq(false))
       end
     end
 
@@ -198,15 +189,15 @@ describe "Asset" do
       it "is not equal to a non-Asset object" do
         AssetCloud::Asset.new(@cloud, "products/foo, bar.txt", "data")
 
-        expect(@asset == "some_string").to eq(false)
-        expect(@asset == :some_symbol).to eq(false)
-        expect(@asset == []).to eq(false)
-        expect(@asset == nil).to eq(false)
+        expect(@asset == "some_string").to(eq(false))
+        expect(@asset == :some_symbol).to(eq(false))
+        expect(@asset == []).to(eq(false))
+        expect(@asset.nil?).to(eq(false))
 
-        expect(@asset <=> "some_string").to eq(nil)
-        expect(@asset <=> :some_symbol).to eq(nil)
-        expect(@asset <=> []).to eq(nil)
-        expect(@asset <=> nil).to eq(nil)
+        expect(@asset <=> "some_string").to(eq(nil))
+        expect(@asset <=> :some_symbol).to(eq(nil))
+        expect(@asset <=> []).to(eq(nil))
+        expect(@asset <=> nil).to(eq(nil))
       end
     end
   end

data/spec/base_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 class SpecialAsset < AssetCloud::Asset
@@ -8,7 +9,7 @@ end
 
 class BasicCloud < AssetCloud::Base
   bucket :special, AssetCloud::MemoryBucket, asset_class: SpecialAsset
-  bucket :conditional, AssetCloud::MemoryBucket, asset_class: Proc.new {|key|
+  bucket :conditional, AssetCloud::MemoryBucket, asset_class: proc { |key|
     LiquidAsset if key.ends_with?('.liquid')
   }
 end
@@ -17,71 +18,69 @@ describe BasicCloud do
   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
-    @fs['image.jpg'].exist?.should == false
+    expect(@fs['image.jpg'].exist?).to(eq(false))
   end
 
-
   it "should be backed by a file system bucket" do
-    @fs['products/key.txt'].exist?.should == true
+    expect(@fs['products/key.txt'].exist?).to(eq(true))
   end
 
   it "should raise when listing non existing buckets" do
-    @fs.ls('products').should == [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.should be_an_instance_of(AssetCloud::Asset)
-    obj.cloud.should be_an_instance_of(BasicCloud)
+    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
-    lambda { @fs['../test']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test']    }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['.../test'] }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['./test']   }.should 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
-    lambda { @fs['test.']             }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile.']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/.']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile .']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory /.'] }.should 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
-    lambda { @fs['test ']             }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile ']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/ ']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test. ']            }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile. ']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/. '] }.should 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
-    lambda { @fs['test/']             }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory/']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test /']            }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['/test/testfile /']  }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/directory//']  }.should 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
-    lambda { @fs['test/../test']      }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/../../test']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test/../../../test']}.should 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
-    lambda { @fs['test. . . .. ... .. . ']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test. .']   }.should raise_error(AssetCloud::IllegalPath)
-    lambda { @fs['test.   .test2']   }.should 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
@@ -125,41 +124,41 @@ describe BasicCloud do
   end
 
   it "should compute complete urls to assets" do
-    @fs.url_for('products/[key] with spaces.txt?foo=1&bar=2').should == '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')
-      asset.key.should == 'products/key.txt'
-      asset.value.should == 'value'
+      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
-      lambda { @fs.find('products/not-there.txt') }.should 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']
-      asset.key.should == 'products/key.txt'
-      asset.value.should == 'value'
+      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
-      lambda { @fs['products/not-there.txt'] }.should_not 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']
-      asset.key.should == 'products/key.txt'
-      asset.value.should == 'value'
+      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']
-      new_asset.key.should == 'products/key2.txt'
-      new_asset.value.should == 'value'
-      expect {@fs['products/key.txt'].value }.to raise_error(AssetCloud::AssetNotFoundError)
+      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
@@ -167,46 +166,45 @@ describe BasicCloud do
   describe "#[]=" do
     it "should write through the Asset object (and thus run any callbacks on the asset)" do
       special_asset = double(:special_asset)
-      special_asset.should_receive(:value=).with('fancy fancy!')
-      special_asset.should_receive(:store)
-      SpecialAsset.should_receive(:at).and_return(special_asset)
+      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!'
     end
   end
 
   describe "#bucket" do
     it "should allow specifying a class to use for assets in this bucket" do
-      @fs['assets/rails_logo.gif'].should be_instance_of(AssetCloud::Asset)
-      @fs['special/fancy.txt'].should 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))
 
-      @fs.build('assets/foo').should be_instance_of(AssetCloud::Asset)
-      @fs.build('special/foo').should 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
-      @fs.build('conditional/default.js').should be_instance_of(AssetCloud::Asset)
-      @fs.build('conditional/better.liquid').should 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
-      expect { BasicCloud.bucket(AssetCloud::MemoryBucket, asset_class: Proc.new {}) }.to(raise_error(ArgumentError))
+      expect { BasicCloud.bucket(AssetCloud::MemoryBucket, asset_class: proc {}) }.to(raise_error(ArgumentError))
     end
   end
 
   describe "MATCH_BUCKET" do
     it "should match following stuff " do
-
       'products/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == 'products'
+      expect(Regexp.last_match(1)).to(eq('products'))
 
       'products/subpath/key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == 'products'
+      expect(Regexp.last_match(1)).to(eq('products'))
 
       'key.txt' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == nil
+      expect(Regexp.last_match(1)).to(eq(nil))
 
       'products' =~ AssetCloud::Base::MATCH_BUCKET
-      $1.should == 'products'
+      expect(Regexp.last_match(1)).to(eq('products'))
     end
   end
 end