ruby-thumbor 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 619894cedb07f907548f9fd762a236775c7cf224
-  data.tar.gz: 6e94d8844c1da9d631933334607a948eb4b52958
+SHA256:
+  metadata.gz: 3aea89d8e9ceb84d32afce82d907f37e9a36387f599cd99947955259142c2149
+  data.tar.gz: 724e15742e517340b63889d356d6195d6c6244e8835dffb86eb5ad7d873bba61
 SHA512:
-  metadata.gz: 74125821b2fd078fef7635c302a3842fbbf2041a2599321acda4cde19ca268c5d74e8b4069de5aaf24e6ab2c87afb5439d64556284944f37b08066502d25d66f
-  data.tar.gz: ee17011292ba6e85a4c784d854260c348ca10661aee4d5c600f41c82a5c91fe17c5410e0cefe7ca5710ff952722179861419c37a9fd78fa6b35be12fb0d83cec
+  metadata.gz: e17c2247defe2aa6674d7b6f9ffe299207fed86acffc180c926c3d21d6a2d81bd33faddfcf2290d4fe39bcc6473836d25eb3e2045dd1b383ccb0a6810243780c
+  data.tar.gz: e76fe2e009b22c96f82d6ea2834a02faec7af7d5ebfbe4416c990020f3e23f880aa36a0060e89b46f3708453d6f9e6eafdcd937ae019be92bde6ccb7c015ff41

data/README.rdoc

@@ -1,5 +1,4 @@
-= ruby-thumbor {<img src="https://secure.travis-ci.org/thumbor/ruby-thumbor.png?branch=master" alt="Build Status" />}[http://travis-ci.org/thumbor/ruby-thumbor] {<img src="https://gemnasium.com/thumbor/ruby-thumbor.png" alt="Dependency Status" />}[https://gemnasium.com/thumbor/ruby-thumbor] {<img src="https://badge.fury.io/rb/ruby-thumbor.svg" alt="Gem Version" />}[http://badge.fury.io/rb/ruby-thumbor] {<img src="https://coveralls.io/repos/thumbor/ruby-thumbor/badge.svg?branch=master&service=github" alt="Coverage Status" />}[https://coveralls.io/github/thumbor/ruby-thumbor?branch=master]
-
+= ruby-thumbor {<img src="https://secure.travis-ci.org/thumbor/ruby-thumbor.png?branch=master" alt="Build Status" />}[http://travis-ci.org/thumbor/ruby-thumbor] {<img src="https://badge.fury.io/rb/ruby-thumbor.svg" alt="Gem Version" />}[http://badge.fury.io/rb/ruby-thumbor] {<img src="https://coveralls.io/repos/thumbor/ruby-thumbor/badge.svg?branch=master&service=github" alt="Coverage Status" />}[https://coveralls.io/github/thumbor/ruby-thumbor?branch=master]
 
 
 * http://github.com/thumbor/ruby-thumbor
@@ -25,9 +24,10 @@ No dependencies required for regular usage.
 
     gem 'ruby-thumbor'
 
-== BREAKING CHANGE ON 2.0:
+== BREAKING CHANGE ON 3.0:
 
-    Thumbor::Cascade.new now gets key, image
+    Old image Url isn't supported anymore
+    Switch from #url_for to #generate method
 
 == USAGE:
 
@@ -35,17 +35,19 @@ No dependencies required for regular usage.
 
     crypto = Thumbor::CryptoURL.new 'my-security-key'
 
-    url = crypto.generate :width => 200, :height => 300, :image => 'my.server.com/path/to/image.jpg'
+    url = crypto.generate :width => 200, :height => 300, :image => 'remote-image.com/path/to/image.jpg'
 
     # url will contain something like:
-    # /2913921in321n3k2nj32hjhj3h22/my.server.com/path/to/image.jpg
+    # /2913921in321n3k2nj32hjhj3h22/remote-image.com/path/to/image.jpg
+
+    # Now you just need to concatenate this generated path, with your thumbor server url
 
 or
 
     require 'ruby-thumbor'
 
-    image = Thumbor::Cascade.new('my-security-key', 'my.server.com/path/to/image.jpg')
-    image.width(300).height(200).watermark_filter('http://my-server.com/image.png', 30).generate
+    image = Thumbor::Cascade.new('my-security-key', 'remote-image.com/path/to/image.jpg')
+    image.width(300).height(200).watermark_filter('http://remote-image.com/path/to/image.jpg', 30).generate
 
 Available arguments to the generate method:
 
@@ -70,6 +72,8 @@ Available arguments to the generate method:
 
     :smart => <bool> - flag that indicates that thumbor should use smart cropping;
 
+    :filters => ['blur(20)', 'watermark(http://my.site.com/img.png,-10,-10,50)'] - array of filters and their arguments
+
 If you need more info on what each option does, check thumbor's documentation at https://github.com/thumbor/thumbor/wiki.
 
 == CONTRIBUTIONS:

data/lib/ruby-thumbor.rb

@@ -3,4 +3,3 @@ require 'thumbor/cascade'
 
 module Thumbor
 end
-

data/lib/thumbor/cascade.rb

@@ -6,7 +6,7 @@ require 'cgi'
 
 module Thumbor
   class Cascade
-    attr_accessor :image, :old_crypto, :options, :filters
+    attr_accessor :image, :crypto, :options, :filters
 
     @available_options = [
       :meta, :crop, :center,
@@ -15,11 +15,11 @@ module Thumbor
       :flop, :halign, :valign,
       :smart, :fit_in, :adaptive_fit_in,
       :full_fit_in, :adaptive_full_fit_in,
-      :old, :trim]
+      :trim, :debug]
 
     extend Forwardable
 
-    def_delegators :@old_crypto, :computed_key
+    def_delegators :@crypto, :computed_key
 
     @available_options.each do |opt|
       define_method(opt) do |*args|
@@ -34,15 +34,11 @@ module Thumbor
       @image = image
       @options = {}
       @filters = []
-      @old_crypto = Thumbor::CryptoURL.new @key
-    end
-
-    def url_for
-      @old_crypto.url_for prepare_options(@options).merge({image: @image, filters: @filters})
+      @crypto = Thumbor::CryptoURL.new @key
     end
 
     def generate
-      @old_crypto.generate prepare_options(@options).merge({image: @image, filters: @filters})
+      @crypto.generate prepare_options(@options).merge({image: @image, filters: @filters})
     end
 
     def method_missing(m, *args)

data/lib/thumbor/crypto_url.rb

@@ -5,7 +5,7 @@ require 'cgi'
 
 module Thumbor
     class CryptoURL
-        attr_accessor :computed_key
+        attr_writer :computed_key
 
         def initialize(key=false)
             @key = key
@@ -15,10 +15,6 @@ module Thumbor
             (@key * 16)[0..15]
         end
 
-        def pad(s)
-            s + ("{" * (16 - s.length % 16))
-        end
-
         def calculate_width_and_height(url_parts, options)
             width = options[:width]
             height = options[:height]
@@ -125,13 +121,17 @@ module Thumbor
             options[:crop] = crop
         end
 
-        def url_for(options, include_hash = true)
+        def url_for(options)
             if not options[:image]
                 raise 'image is a required argument.'
             end
 
             url_parts = Array.new
 
+            if options[:debug]
+                url_parts.push('debug')
+            end
+
             if options[:trim]
                 trim_options  = ['trim']
                 trim_options << options[:trim] unless options[:trim] == true or options[:trim][0] == true
@@ -189,11 +189,6 @@ module Thumbor
               url_parts.push("filters:#{ filter_parts.join(':') }")
             end
 
-            if include_hash
-                image_hash = Digest::MD5.hexdigest(options[:image])
-                url_parts.push(image_hash)
-            end
-
             return url_parts.join('/')
         end
 
@@ -201,20 +196,10 @@ module Thumbor
             Base64.encode64(str).gsub('+', '-').gsub('/', '_').gsub!(/[\n]/, '')
         end
 
-        def generate_old(options)
-            url = pad(url_for(options))
-            cipher = OpenSSL::Cipher::Cipher.new('aes-128-ecb').encrypt
-            cipher.key = computed_key
-            encrypted = cipher.update(url)
-            based = url_safe_base64(encrypted)
-
-            "/#{based}/#{options[:image]}"
-        end
-
-        def generate_new(options)
+        def generate(options)
             thumbor_path = ""
 
-            image_options = url_for(options, false)
+            image_options = url_for(options)
             thumbor_path << image_options + '/' unless image_options.empty?
 
             thumbor_path << options[:image]
@@ -227,10 +212,5 @@ module Thumbor
             end
             thumbor_path
         end
-
-        def generate(options)
-            return generate_old(options) if options[:old]
-            generate_new(options)
-        end
     end
 end

data/lib/thumbor/version.rb

@@ -1,3 +1,3 @@
 module Thumbor
-  VERSION = '2.0.1'
+  VERSION = '3.0.0'
 end

data/spec/spec_helper.rb

@@ -1,12 +1,16 @@
 require 'simplecov'
-require 'coveralls'
-Coveralls.wear!
+begin
+  require 'coveralls'
+rescue LoadError
+  puts 'Running on Jruby'
+end
+
+Coveralls.wear! if defined? Coveralls
 
 SimpleCov.start do
   add_filter '/spec/'
 end
 
-
 RSpec.configure do |c|
   c.filter_run :focus => true
   c.run_all_when_everything_filtered = true

data/spec/thumbor/cascade_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
 require 'json'
 require 'ruby-thumbor'
-require 'util/thumbor'
 
 describe Thumbor::Cascade do
   let(:image_url) { 'my.domain.com/some/image/url.jpg' }
-  let(:image_md5) { 'f33af67e41168e80fcc5b00f8bd8061a' }
   let(:key) { 'my-security-key' }
 
   subject { Thumbor::Cascade.new key, image_url }
@@ -21,477 +19,302 @@ describe Thumbor::Cascade do
     expect{ subject.god_of_war_crop }.to raise_error(NoMethodError)
   end
 
-  describe '#url_for' do
+  describe '#generate' do
+
+    it "should create an unsafe url" do
+      url = Thumbor::Cascade.new(false, image_url).width(300).height(200).generate
+      expect(url).to eq '/unsafe/300x200/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should create an url with debug" do
+      url = subject.debug(true).height(200).generate
+      expect(url).to eq '/5_eX4HHQYk81HQVkc1gBIAvPbLo=/debug/0x200/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should create a new instance passing key and keep it" do
+      url = subject.width(300).height(200).generate
+      expect(url).to eq '/TQfyd3H36Z3srcNcLOYiM05YNO8=/300x200/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should be able to change the Thumbor key" do
+      url1 = subject.width(300).height(200).generate
+      url2 = Thumbor::Cascade.new('another-thumbor-key', image_url).width(300).height(200).generate
+      expect(url1).not_to eq url2
+    end
+
+    it "should create a new instance passing key and keep it" do
+      url = subject.width(300).height(200).meta(true).generate
+      expect(url).to eq '/YBQEWd3g_WRMnVEG73zfzcr8Zj0=/meta/300x200/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should create a new instance passing key and keep it" do
+      url = subject.width(300).height(200).meta(true).smart(true).generate
+      expect(url).to eq '/jP89J0qOWHgPlm_lOA28GtOh5GU=/meta/300x200/smart/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should create a new instance passing key and keep it" do
+      url = subject.width(300).height(200).meta(true).smart(true).fit_in(true).generate
+      expect(url).to eq '/zrrOh_TtTs4kiLLEQq1w4bcTYdc=/meta/fit-in/300x200/smart/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should create a new instance passing key and keep it" do
+      url = subject.width(300).height(200).meta(true).smart(true).fit_in(true).flip(true).generate
+      expect(url).to eq '/4t1XK1KH43cOb1QJ9tU00-W2_k8=/meta/fit-in/-300x200/smart/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should create a new instance passing key and keep it" do
+      url = subject.width(300).height(200).meta(true).smart(true).fit_in(true).flip(true).flop(true).generate
+      expect(url).to eq '/HJnvjZU69PkPOhyZGu-Z3Uc_W_A=/meta/fit-in/-300x-200/smart/my.domain.com/some/image/url.jpg'
+    end
+
+    it "should create a new instance passing key and keep it" do
+      url = subject.quality_filter(20).brightness_filter(10).generate
+      expect(url).to eq '/q0DiFg-5-eFZIqyN3lRoCvg2K0s=/filters:quality(20):brightness(10)/my.domain.com/some/image/url.jpg'
+    end
 
     it "should return just the image hash if no arguments passed" do
-      url = subject.url_for
-      expect(url).to eq image_md5
+      url = subject.generate
+      expect(url).to eq '/964rCTkAEDtvjy_a572k7kRa0SU=/my.domain.com/some/image/url.jpg'
     end
 
     it "should raise if no image passed" do
-      expect { Thumbor::Cascade.new.url_for }.to raise_error(RuntimeError)
+      expect { Thumbor::Cascade.new.generate }.to raise_error(RuntimeError)
     end
 
     it "should return proper url for width-only" do
-      url = subject.width(300).url_for
-      expect(url).to eq '300x0/' << image_md5
+      url = subject.width(300).generate
+      expect(url).to eq '/eFwrBWryxtRw9hDSbQPhi5iLpo8=/300x0/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper url for height-only" do
-      url = subject.height(300).url_for
-      expect(url).to eq '0x300/' << image_md5
+      url = subject.height(300).generate
+      expect(url).to eq '/-VGIgp7g8cMKcfF2gFK9ZpmB_5w=/0x300/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper url for width and height" do
-      url = subject.width(200).height(300).url_for
-      expect(url).to eq '200x300/' << image_md5
+      url = subject.width(200).height(300).generate
+      expect(url).to eq '/TrM0qqfcivb6VxS3Hxlxn43W21k=/200x300/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper smart url" do
-      url = subject.width(200).height(300).smart(true).url_for
-      expect(url).to eq '200x300/smart/' << image_md5
+      url = subject.width(200).height(300).smart(true).generate
+      expect(url).to eq '/hdzhxXzK45DzNTru5urV6x6xxSs=/200x300/smart/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper fit-in url" do
-      url = subject.width(200).height(300).fit_in(true).url_for
-      expect(url).to eq 'fit-in/200x300/' << image_md5
+      url = subject.width(200).height(300).fit_in(true).generate
+      expect(url).to eq '/LOv6ArMOJA2VRpfMQjjs4xSyZpM=/fit-in/200x300/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper adaptive-fit-in url" do
-      url = subject.width(200).height(300).adaptive_fit_in(true).url_for
-      expect(url).to eq 'adaptive-fit-in/200x300/' << image_md5
+      url = subject.width(200).height(300).adaptive_fit_in(true).generate
+      expect(url).to eq '/V2xmSmQZm4i5-0Flx8iuRtawOkg=/adaptive-fit-in/200x300/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper full-fit-in url" do
-      url = subject.width(200).height(300).full_fit_in(true).url_for
-      expect(url).to eq 'full-fit-in/200x300/' << image_md5
+      url = subject.width(200).height(300).full_fit_in(true).generate
+      expect(url).to eq '/geXhR7ZFxztQTsKzmkDxYCX-HHg=/full-fit-in/200x300/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper adaptive-full-fit-in url" do
-      url = subject.width(200).height(300).adaptive_full_fit_in(true).url_for
-      expect(url).to eq 'adaptive-full-fit-in/200x300/' << image_md5
+      url = subject.width(200).height(300).adaptive_full_fit_in(true).generate
+      expect(url).to eq '/jlUfjdC-6rG6jmuHgFp6eKgPy2g=/adaptive-full-fit-in/200x300/my.domain.com/some/image/url.jpg'
     end
 
     [:fit_in, :full_fit_in].each do |fit|
       it "should raise error when using #{fit} without width or height" do
         subject.send(fit, true)
-        expect{subject.url_for}.to raise_error(ArgumentError)
+        expect{subject.generate}.to raise_error(ArgumentError)
       end
     end
 
     it "should return proper flip url if no width and height" do
-      url = subject.flip(true).url_for
-      expect(url).to eq '-0x0/' << image_md5
+      url = subject.flip(true).generate
+      expect(url).to eq '/rlI4clPR-p-PR2QAxj5ZWiTfvH4=/-0x0/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper flop url if no width and height" do
-      url = subject.flop(true).url_for
-      expect(url).to eq '0x-0/' << image_md5
+      url = subject.flop(true).generate
+      expect(url).to eq '/-4dmGj-TwIEqTAL9_9yEqUM8cks=/0x-0/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper flip-flop url if no width and height" do
-      url = subject.flip(true).flop(true).url_for
-      expect(url).to eq '-0x-0/' << image_md5
+      url = subject.flip(true).flop(true).generate
+      expect(url).to eq '/FnMxpQMmxiMpdG219Dsj8pD_4Xc=/-0x-0/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper flip url if width" do
-      url = subject.width(300).flip(true).url_for
-      expect(url).to eq '-300x0/' << image_md5
+      url = subject.width(300).flip(true).generate
+      expect(url).to eq '/ccr2PoSYcTEGL4_Wzt4u3wWVRKU=/-300x0/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper flop url if height" do
-      url = subject.height(300).flop(true).url_for
-      expect(url).to eq '0x-300/' << image_md5
+      url = subject.height(300).flop(true).generate
+      expect(url).to eq '/R5K91tkyNgXO65F6E0txgA6C9lY=/0x-300/my.domain.com/some/image/url.jpg'
     end
 
     it "should return horizontal align" do
-      url = subject.halign(:left).url_for
-      expect(url).to eq 'left/' << image_md5
+      url = subject.halign(:left).generate
+      expect(url).to eq '/GTJE3wUt3sURik0O9Nae8sfI928=/left/my.domain.com/some/image/url.jpg'
     end
 
     it "should not return horizontal align if it is center" do
-      url = subject.halign(:center).url_for
-      expect(url).to eq image_md5
+      url = subject.halign(:center).generate
+      expect(url).to eq '/964rCTkAEDtvjy_a572k7kRa0SU=/my.domain.com/some/image/url.jpg'
     end
 
     it "should return vertical align" do
-      url = subject.valign(:top).url_for
-      expect(url).to eq 'top/' << image_md5
+      url = subject.valign(:top).generate
+      expect(url).to eq '/1QQo5ihObuhgwl95--Z3g78vjiE=/top/my.domain.com/some/image/url.jpg'
     end
 
     it "should not return vertical align if it is middle" do
-      url = subject.valign(:middle).url_for
-      expect(url).to eq image_md5
+      url = subject.valign(:middle).generate
+      expect(url).to eq '/964rCTkAEDtvjy_a572k7kRa0SU=/my.domain.com/some/image/url.jpg'
     end
 
     it "should return halign and valign properly" do
-      url = subject.halign(:left).valign(:top).url_for
-      expect(url).to eq 'left/top/' << image_md5
+      url = subject.halign(:left).valign(:top).generate
+      expect(url).to eq '/yA2rmtWv_uzHd9klz5OuMIZ5auI=/left/top/my.domain.com/some/image/url.jpg'
     end
 
     it "should return meta properly" do
-      url = subject.meta(true).url_for
-      expect(url).to eq 'meta/' << image_md5
+      url = subject.meta(true).generate
+      expect(url).to eq '/WvIJFDJDePgIl5hZcLgtrzIPxfY=/meta/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper crop url when param is array" do
-      url = subject.crop([10, 20, 30, 40]).url_for
-      expect(url).to eq '10x20:30x40/' << image_md5
+      url = subject.crop([10, 20, 30, 40]).generate
+      expect(url).to eq '/QcnhqNfHwiP6BHLbD6UvneX7K28=/10x20:30x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should return proper crop url" do
-      url = subject.crop(10, 20, 30, 40).url_for
-      expect(url).to eq '10x20:30x40/' << image_md5
+      url = subject.crop(10, 20, 30, 40).generate
+      expect(url).to eq '/QcnhqNfHwiP6BHLbD6UvneX7K28=/10x20:30x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should ignore crop if all zeros" do
-      url = subject.crop(0, 0, 0, 0).url_for
-      expect(url).to eq image_md5
+      url = subject.crop(0, 0, 0, 0).generate
+      expect(url).to eq '/964rCTkAEDtvjy_a572k7kRa0SU=/my.domain.com/some/image/url.jpg'
     end
 
     it "should have smart after halign and valign" do
-      url = subject.halign(:left).valign(:top).smart(true).url_for
-      expect(url).to eq 'left/top/smart/' << image_md5
+      url = subject.halign(:left).valign(:top).smart(true).generate
+      expect(url).to eq '/KS6mVuzlGE3hJ75n3JUonfGgSFM=/left/top/smart/my.domain.com/some/image/url.jpg'
     end
 
     it "should have quality filter" do
-      url = subject.quality_filter(20).url_for
-      expect(url).to eq 'filters:quality(20)/' << image_md5
+      url = subject.quality_filter(20).generate
+      expect(url).to eq '/NyA-is4NojxiRqo0NcmJDhB6GTs=/filters:quality(20)/my.domain.com/some/image/url.jpg'
     end
 
     it "should have brightness filter" do
-      url = subject.brightness_filter(30).url_for
-      expect(url).to eq 'filters:brightness(30)/' << image_md5
+      url = subject.brightness_filter(30).generate
+      expect(url).to eq '/oXDmnGD7vQV-rXcj8kCl1tcS3jc=/filters:brightness(30)/my.domain.com/some/image/url.jpg'
     end
 
     it "should have 2 filters" do
-      url = subject.brightness_filter(30).quality_filter(20).url_for
-      expect(url).to eq 'filters:brightness(30):quality(20)/' << image_md5
+      url = subject.brightness_filter(30).quality_filter(20).generate
+      expect(url).to eq '/SW9o4xQG1QAzE69WzEzarL_G3MI=/filters:brightness(30):quality(20)/my.domain.com/some/image/url.jpg'
     end
 
     it "should escape url args" do
-      url = subject.watermark_filter('http://my-server.com/image.png', 30).quality_filter(20).url_for
-      expect(url).to eq 'filters:watermark(http%3A%2F%2Fmy-server.com%2Fimage.png,30):quality(20)/' << image_md5
+      url = subject.watermark_filter('http://my-server.com/image.png', 30).quality_filter(20).generate
+      expect(url).to eq '/4b9kwg0-zsojf7Ed01TPKPYOel4=/filters:watermark(http%3A%2F%2Fmy-server.com%2Fimage.png,30):quality(20)/my.domain.com/some/image/url.jpg'
     end
 
     it "should have trim without params" do
-      url = subject.trim.url_for
-      expect(url).to eq 'trim/' << image_md5
+      url = subject.trim.generate
+      expect(url).to eq '/w23BC0dUiYBFrUnuoYJe8XROuyw=/trim/my.domain.com/some/image/url.jpg'
     end
 
     it "should have trim with direction param" do
-      url = subject.trim('bottom-right').url_for
-      expect(url).to eq 'trim:bottom-right/' << image_md5
+      url = subject.trim('bottom-right').generate
+      expect(url).to eq '/kXPwSmqEvPFQezgzBCv9BtPWmBY=/trim:bottom-right/my.domain.com/some/image/url.jpg'
     end
 
     it "should have trim with direction and tolerance param" do
-      url = subject.trim('bottom-right', 15).url_for
-      expect(url).to eq 'trim:bottom-right:15/' << image_md5
+      url = subject.trim('bottom-right', 15).generate
+      expect(url).to eq '/TUCEIhtWfI1Uv9zjavCSl_i0A_8=/trim:bottom-right:15/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop when cropping horizontally and given a left center" do
-      url = subject.original_width(100).original_height(100).width(40).height(50).center(0, 50).url_for
-      expect(url).to eq '0x0:80x100/40x50/' << image_md5
+      url = subject.original_width(100).original_height(100).width(40).height(50).center(0, 50).generate
+      expect(url).to eq '/SZIT3w4Qgebv5DuVJ8G1IH1mkCU=/0x0:80x100/40x50/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop when cropping horizontally and given a right center" do
-      url = subject.original_width(100).original_height(100).width(40).height(50).center(100, 50).url_for
-      expect(url).to eq '20x0:100x100/40x50/' << image_md5
+      url = subject.original_width(100).original_height(100).width(40).height(50).center(100, 50).generate
+      expect(url).to eq '/NEtCYehaISE7qR3zFj15CxnZoCs=/20x0:100x100/40x50/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop when cropping horizontally and given the actual center" do
-      url = subject.original_width(100).original_height(100).width(40).height(50).center(50, 50).url_for
-      expect(url).to eq '10x0:90x100/40x50/' << image_md5
+      url = subject.original_width(100).original_height(100).width(40).height(50).center(50, 50).generate
+      expect(url).to eq '/JLH65vJTu6d-cXBmqe5hYoSD4ho=/10x0:90x100/40x50/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop when cropping vertically and given a top center" do
-      url = subject.original_width(100).original_height(100).width(50).height(40).center(50, 0).url_for
-      expect(url).to eq '0x0:100x80/50x40/' << image_md5
+      url = subject.original_width(100).original_height(100).width(50).height(40).center(50, 0).generate
+      expect(url).to eq '/FIMZcLatW6bjgSRH9xTkEwUZAZ8=/0x0:100x80/50x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop when cropping vertically and given a bottom center" do
-      url = subject.original_width(100).original_height(100).width(50).height(40).center(50, 100).url_for
-      expect(url).to eq '0x20:100x100/50x40/' << image_md5
+      url = subject.original_width(100).original_height(100).width(50).height(40).center(50, 100).generate
+      expect(url).to eq '/9Ud0sVo6i9DLOjlKbQP_4JXgFmA=/0x20:100x100/50x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop when cropping vertically and given the actual center" do
-      url = subject.original_width(100).original_height(100).width(50).height(40).center(50, 50).url_for
-      expect(url).to eq '0x10:100x90/50x40/' << image_md5
+      url = subject.original_width(100).original_height(100).width(50).height(40).center(50, 50).generate
+      expect(url).to eq '/WejLJn8djJLn7DkMUq3S0zZCvZE=/0x10:100x90/50x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the no crop when not necessary" do
-      url = subject.original_width(100).original_height(100).width(50).height(50).center(50, 0).url_for
-      expect(url).to eq '50x50/' << image_md5
+      url = subject.original_width(100).original_height(100).width(50).height(50).center(50, 0).generate
+      expect(url).to eq '/trIjfr513nkGkCpKXK6qgox2jPA=/50x50/my.domain.com/some/image/url.jpg'
     end
 
     it "should blow up with a bad center" do
-      expect { subject.original_width(100).original_height(100).width(50).height(50).center(50).url_for }.to raise_error(RuntimeError)
+      expect { subject.original_width(100).original_height(100).width(50).height(50).center(50).generate }.to raise_error(RuntimeError)
     end
 
     it "should have no crop with a missing original_height" do
-      url = subject.original_width(100).width(50).height(40).center(50, 0).url_for
-      expect(url).to eq '50x40/' << image_md5
+      url = subject.original_width(100).width(50).height(40).center(50, 0).generate
+      expect(url).to eq '/veYlY0msKmemAaXpeav2kCNftmU=/50x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should have no crop with a missing original_width" do
-      url = subject.original_height(100).width(50).height(40).center(50, 0).url_for
-      expect(url).to eq '50x40/' << image_md5
+      url = subject.original_height(100).width(50).height(40).center(50, 0).generate
+      expect(url).to eq '/veYlY0msKmemAaXpeav2kCNftmU=/50x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should have no crop with out a width and height" do
-      url = subject.original_width(100).original_height(100).center(50, 50).url_for
-      expect(url).to eq image_md5
+      url = subject.original_width(100).original_height(100).center(50, 50).generate
+      expect(url).to eq '/964rCTkAEDtvjy_a572k7kRa0SU=/my.domain.com/some/image/url.jpg'
     end
 
     it "should use the original width with a missing width" do
-      url = subject.original_width(100).original_height(100).height(80).center(50, 50).url_for
-      expect(url).to eq '0x10:100x90/0x80/' << image_md5
+      url = subject.original_width(100).original_height(100).height(80).center(50, 50).generate
+      expect(url).to eq '/02BNIIJ9NYNV9Q03JHPtlP0DIDg=/0x10:100x90/0x80/my.domain.com/some/image/url.jpg'
     end
 
     it "should use the original height with a missing height" do
-      url = subject.original_width(100).original_height(100).width(80).center(50, 50).url_for
-      expect(url).to eq '10x0:90x100/80x0/' << image_md5
+      url = subject.original_width(100).original_height(100).width(80).center(50, 50).generate
+      expect(url).to eq '/0XL5BmMi3vlJQfw6aGOVW-M1vVI=/10x0:90x100/80x0/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop with a negative width" do
-      url = subject.original_width(100).original_height(100).width(-50).height(40).center(50, 50).url_for
-      expect(url).to eq '0x10:100x90/-50x40/' << image_md5
+      url = subject.original_width(100).original_height(100).width(-50).height(40).center(50, 50).generate
+      expect(url).to eq '/IuRNPlFlpTVol45bDkOm2PGvneo=/0x10:100x90/-50x40/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop with a negative height" do
-      url = subject.original_width(100).original_height(100).width(50).height(-40).center(50, 50).url_for
-      expect(url).to eq '0x10:100x90/50x-40/' << image_md5
+      url = subject.original_width(100).original_height(100).width(50).height(-40).center(50, 50).generate
+      expect(url).to eq '/-8IhWGEeXaY1uv945i9EHLVjwuk=/0x10:100x90/50x-40/my.domain.com/some/image/url.jpg'
     end
 
     it "should have the right crop with a negative height and width" do
-      url = subject.original_width(100).original_height(100).width(-50).height(-40).center(50, 50).url_for
-      expect(url).to eq '0x10:100x90/-50x-40/' << image_md5
-    end
-  end
-
-  describe '#generate' do
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.width(300).height(200).generate
-      expect(url).to eq '/TQfyd3H36Z3srcNcLOYiM05YNO8=/300x200/my.domain.com/some/image/url.jpg'
-    end
-
-    it "should be able to change the Thumbor key" do
-      url1 = subject.width(300).height(200).generate
-      url2 = Thumbor::Cascade.new('another-thumbor-key', image_url).width(300).height(200).generate
-      expect(url1).not_to eq url2
-    end
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.width(300).height(200).meta(true).generate
-      expect(url).to eq '/YBQEWd3g_WRMnVEG73zfzcr8Zj0=/meta/300x200/my.domain.com/some/image/url.jpg'
-    end
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.width(300).height(200).meta(true).smart(true).generate
-      expect(url).to eq '/jP89J0qOWHgPlm_lOA28GtOh5GU=/meta/300x200/smart/my.domain.com/some/image/url.jpg'
-    end
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.width(300).height(200).meta(true).smart(true).fit_in(true).generate
-      expect(url).to eq '/zrrOh_TtTs4kiLLEQq1w4bcTYdc=/meta/fit-in/300x200/smart/my.domain.com/some/image/url.jpg'
-    end
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.width(300).height(200).meta(true).smart(true).fit_in(true).flip(true).generate
-      expect(url).to eq '/4t1XK1KH43cOb1QJ9tU00-W2_k8=/meta/fit-in/-300x200/smart/my.domain.com/some/image/url.jpg'
-    end
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.width(300).height(200).meta(true).smart(true).fit_in(true).flip(true).flop(true).generate
-      expect(url).to eq '/HJnvjZU69PkPOhyZGu-Z3Uc_W_A=/meta/fit-in/-300x-200/smart/my.domain.com/some/image/url.jpg'
-    end
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.quality_filter(20).brightness_filter(10).generate
-      expect(url).to eq '/q0DiFg-5-eFZIqyN3lRoCvg2K0s=/filters:quality(20):brightness(10)/my.domain.com/some/image/url.jpg'
-    end
-  end
-
-  describe "#generate :old => true" do
-
-    subject { Thumbor::Cascade.new(key, image_url).old(true) }
-
-    it "should create a new instance passing key and keep it" do
-      url = subject.width(300).height(200).generate
-      expect(url).to eq '/qkLDiIbvtiks0Up9n5PACtmpOfX6dPXw4vP4kJU-jTfyF6y1GJBJyp7CHYh1H3R2/' << image_url
-    end
-
-    it "should allow thumbor to decrypt it properly" do
-      url = subject.width(300).height(200).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["horizontal_flip"]).to be_falsy
-      expect(decrypted["vertical_flip"]).to be_falsy
-      expect(decrypted["smart"]).to be_falsy
-      expect(decrypted["meta"]).to be_falsy
-      expect(decrypted["fit_in"]).to be_falsy
-      expect(decrypted["crop"]["left"]).to eq 0
-      expect(decrypted["crop"]["top"]).to eq 0
-      expect(decrypted["crop"]["right"]).to eq 0
-      expect(decrypted["crop"]["bottom"]).to eq 0
-      expect(decrypted["valign"]).to eq 'middle'
-      expect(decrypted["halign"]).to eq 'center'
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-
-    end
-
-    it "should allow thumbor to decrypt it properly with meta" do
-      url = subject.width(300).height(200).meta(true).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["meta"]).to be_truthy
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-
-    end
-
-    it "should allow thumbor to decrypt it properly with smart" do
-      url = subject.width(300).height(200).meta(true).smart(true).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["meta"]).to be_truthy
-      expect(decrypted["smart"]).to be_truthy
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-
-    end
-
-    it "should allow thumbor to decrypt it properly with fit-in" do
-      url = subject.width(300).height(200).fit_in(true).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["fit_in"]).to be_truthy
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-
-    end
-
-    it "should allow thumbor to decrypt it properly with flip" do
-      url = subject.width(300).height(200).meta(true).smart(true).flip(true).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["meta"]).to be_truthy
-      expect(decrypted["smart"]).to be_truthy
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-      expect(decrypted["horizontal_flip"]).to be_truthy
-
-    end
-
-    it "should allow thumbor to decrypt it properly with flop" do
-      url = subject.width(300).height(200).meta(true).smart(true).flip(true).flop(true).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["meta"]).to be_truthy
-      expect(decrypted["smart"]).to be_truthy
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-      expect(decrypted["horizontal_flip"]).to be_truthy
-      expect(decrypted["vertical_flip"]).to be_truthy
-
-    end
-
-    it "should allow thumbor to decrypt it properly with halign" do
-      url = subject.width(300).height(200).meta(true).smart(true).flip(true).flop(true).
-            halign(:left).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["meta"]).to be_truthy
-      expect(decrypted["smart"]).to be_truthy
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-      expect(decrypted["horizontal_flip"]).to be_truthy
-      expect(decrypted["vertical_flip"]).to be_truthy
-      expect(decrypted["halign"]).to eq "left"
-
-    end
-
-    it "should allow thumbor to decrypt it properly with valign" do
-      url = subject.width(300).height(200).meta(true).smart(true).flip(true).flop(true).
-            halign(:left).valign(:top).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["meta"]).to be_truthy
-      expect(decrypted["smart"]).to be_truthy
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-      expect(decrypted["horizontal_flip"]).to be_truthy
-      expect(decrypted["vertical_flip"]).to be_truthy
-      expect(decrypted["halign"]).to eq "left"
-      expect(decrypted["valign"]).to eq "top"
-
-    end
-
-    it "should allow thumbor to decrypt it properly with cropping" do
-      url = subject.width(300).height(200).crop([10, 20, 30, 40]).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["horizontal_flip"]).to be_falsy
-      expect(decrypted["vertical_flip"]).to be_falsy
-      expect(decrypted["smart"]).to be_falsy
-      expect(decrypted["meta"]).to be_falsy
-      expect(decrypted["crop"]["left"]).to eq 10
-      expect(decrypted["crop"]["top"]).to eq 20
-      expect(decrypted["crop"]["right"]).to eq 30
-      expect(decrypted["crop"]["bottom"]).to eq 40
-      expect(decrypted["valign"]).to eq 'middle'
-      expect(decrypted["halign"]).to eq 'center'
-      expect(decrypted["image_hash"]).to eq image_md5
-      expect(decrypted["width"]).to eq 300
-      expect(decrypted["height"]).to eq 200
-
-    end
-
-    it "should allow thumbor to decrypt it properly with filters" do
-      url = subject.quality_filter(20).brightness_filter(10).generate
-
-      encrypted = url.split('/')[1]
-
-      decrypted = decrypt_in_thumbor(encrypted)
-
-      expect(decrypted["filters"]).to eq "quality(20):brightness(10)"
+      url = subject.original_width(100).original_height(100).width(-50).height(-40).center(50, 50).generate
+      expect(url).to eq '/lfjGLTTEaW_Rcvc1q0ZhfYup2jg=/0x10:100x90/-50x-40/my.domain.com/some/image/url.jpg'
     end
   end
 end