shutterbug 0.0.11 → 0.1.0

data/lib/shutterbug/rackapp.rb

@@ -1,49 +1,51 @@
 # encoding: utf-8
-
 module Shutterbug
   class Rackapp
 
-    def initialize(app, &block)
+    DefaultHandlers = [
+      Shutterbug::Handlers::ConvertHandler ,
+      Shutterbug::Handlers::JsFileHandler,
+      Shutterbug::Handlers::FileHandlers::PngFile,
+      Shutterbug::Handlers::FileHandlers::HtmlFile
+    ]
+
+    attr_accessor :handlers
+    def add_handler(klass)
+      instance = klass.new(@config)
+      log "adding handler for #{instance.regex} ➙ #{klass.name}"
+      self.handlers[instance.regex] = instance
+    end
+
+    def add_default_handlers
+      DefaultHandlers.each { |h| add_handler(h) }
+    end
+
+    def initialize(app=nil, &block)
+      @handlers = {}
       @config = Configuration.instance
       yield @config if block_given?
       @app = app
-      @shutterbug = Service.new(@config)
+      add_default_handlers
       log "initialized"
     end
 
-    def do_convert(req)
-      html     = req.POST()['content']  ||  ""
-      width    = req.POST()['width']    || 1000
-      height   = req.POST()['height']   ||  700
-      css      = req.POST()['css']      ||  ""
-
-      signature = @shutterbug.convert(@config.base_url(req), html, css, width, height)
-      response_text = "<img src='#{@config.png_path(signature)}' alt='#{signature}'>"
-      return good_response(response_text,'text/plain')
-    end
-
     def call env
-      req = Rack::Request.new(env)
-      case req.path
-      when @config.convert_regex
-        do_convert(req)
-      when @config.png_regex
-        good_response(@shutterbug.get_png_file($1),'image/png')
-      when @config.html_regex
-        good_response(@shutterbug.get_html_file($1),'text/html')
-      when @config.js_regex
-        good_response(@shutterbug.get_shutterbug_file, 'application/javascript')
-      else
-        skip(env)
+      req      = Rack::Request.new(env)
+      result   = false
+      handlers.keys.each do |path_regex|
+        if req.path =~ path_regex
+          result = handlers[path_regex].handle(self, req, env)
+        end
       end
+      result || skip(env)
     end
 
-    private
-    def good_response(content, type, cache='no-cache')
+    def good_response(content, type, cachable=true)
       headers = {}
-      headers['Content-Length'] = content.size.to_s
+      size = content.respond_to?(:bytesize) ? content.bytesize : content.size
+      headers['Content-Length'] = size.to_s
       headers['Content-Type']   = type
-      headers['Cache-Control']  = 'no-cache'
+      headers['Cache-Control']  = 'no-cache' unless cachable
       # content must be enumerable.
       content = [content] if content.kind_of? String
       return [200, headers, content]
@@ -55,7 +57,7 @@ module Shutterbug
 
     def skip(env)
       # call the applicaiton default
-      @app.call env
+      @app.call env if @app
     end
 
   end

data/lib/shutterbug/storage.rb

@@ -0,0 +1,6 @@
+module Shutterbug
+  module Storage
+    autoload :FileStorage,  "shutterbug/storage/file_storage"
+    autoload :S3Storage,    "shutterbug/storage/s3_storage"
+  end
+end

data/lib/shutterbug/storage/file_storage.rb

@@ -0,0 +1,20 @@
+module Shutterbug
+  module Storage
+    class FileStorage
+      attr_accessor :filename
+      attr_accessor :config
+      attr_accessor :url
+
+      def initialize(filename, file_handler)
+        @filename = Configuration.instance.fs_path_for(filename)
+        @url = file_handler.urlify(filename)
+      end
+
+      def get_content
+        file = File.open(@filename, 'r')
+        return file
+      end
+
+    end
+  end
+end

data/lib/shutterbug/storage/s3_storage.rb

@@ -0,0 +1,75 @@
+module Shutterbug
+  module Storage
+    class S3Storage
+      require 'fog'
+
+      attr_accessor :filename
+      attr_accessor :url
+      attr_accessor :stream_file
+
+      def self.connect!
+        Fog::Storage.new({
+          :provider                 => 'AWS',
+          :aws_access_key_id        => Configuration.instance.s3_key,
+          :aws_secret_access_key    => Configuration.instance.s3_secret
+        })
+      end
+
+      def self.connection
+        @connection ||= self.connect!
+      end
+
+      def self.create_bin
+        self.connection.directories.create(
+          :key    => Configuration.instance.s3_bin,
+          :public => true)
+      end
+
+      def self.s3_bin
+        @s3_bin ||= self.create_bin
+      end
+
+      def self.write(name, filename)
+        full_path = Configuration.instance.fs_path_for(filename)
+        if self.fs_path_exists? full_path
+          self.s3_bin.files.create(
+            :key    => name,
+            :body   => File.open(full_path),
+            :public => true)
+        end
+      end
+
+      def self.find(path)
+        self.s3_bin.files.get(path)
+      end
+
+      def self.fs_path_exists?(long_path)
+        File.exists? long_path
+      end
+
+      def self.handler_for(type)
+        return self.handlers[type]
+      end
+
+      def initialize(long_path, filetype)
+        @filename = File.basename(long_path)
+        @source = long_path
+        @stream_file = S3Storage.write(@filename, long_path)
+        @url = @stream_file.public_url
+      end
+
+      def get_content
+        @stream_file.body
+      end
+
+      def size
+        @stream_file.content_length
+      end
+
+      def redirect_s3
+        return [301, {"Location" => self.url}, []]
+      end
+
+    end
+  end
+end

data/shutterbug.gemspec

@@ -30,7 +30,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "rack-cors"
+  spec.add_development_dependency "guard-rack"
+  spec.add_development_dependency "rack-test"
 
   spec.add_dependency "rack"
+  spec.add_dependency "fog"
 
 end

data/spec/shared_examples_for_file_handlers.rb

@@ -0,0 +1,16 @@
+require 'shared_examples_for_handlers'
+shared_examples "a file handler" do
+  let(:config)  { Shutterbug::Configuration.instance}
+  let(:rackapp) { mock }
+  let(:req)     { mock }
+  let(:env)     { mock }
+  let(:handler) { described_class.new(config) }
+
+
+  it "should have a file extension" do
+    handler.should respond_to :file_extension
+  end
+  it "should have a mime type" do
+    handler.should respond_to :mime_type
+  end
+end

data/spec/shared_examples_for_handlers.rb

@@ -0,0 +1,26 @@
+shared_examples "a request handler" do
+  let(:config)  { Shutterbug::Configuration.new()}
+  let(:rackapp) { mock }
+  let(:req)     { mock }
+  let(:env)     { mock }
+  let(:handler) { described_class.new(config) }
+  let(:mock_storage) do
+    mock({
+      :new => mock({
+        :get_content => "content"
+      })
+    })
+  end
+  before(:each) do
+    config.stub!(:storage => mock_storage)
+  end
+  it "should respond to regex" do
+    handler.should respond_to :regex
+    handler.regex.should be_kind_of Regexp
+  end
+  it "should respond to handle" do
+    handler.should respond_to :handle
+    rackapp.should_receive :good_response
+    handler.handle(rackapp,req,env)
+  end
+end

data/spec/shared_examples_for_storage.rb

@@ -0,0 +1,17 @@
+shared_examples "a storage provider" do
+  let(:filetype) { Shutterbug::Handlers::FileHandlers::HtmlFile.new}
+  let(:filename) { "somefilename.html" }
+  let(:provider) { described_class.new(filename,filetype) }
+
+  it "should respond to filename" do
+    provider.should respond_to :filename
+  end
+
+  it "should respond to url" do
+    provider.should respond_to :url
+  end
+
+  it "should respond to get_content" do
+    provider.should respond_to :get_content
+  end
+end

data/spec/shutterbug/configuration_spec.rb

@@ -0,0 +1,83 @@
+
+describe Shutterbug::Configuration do
+
+  let(:uri_prefix)       { "http://blah.com/" }
+  let(:path_prefix)      { "/shutterbug" }
+  let(:resource_dir)     { "resource_dir"}
+  let(:phantom_bin_path) { "phantom_bin_path"}
+  let(:s3_bin)           { nil }
+  let(:s3_key)           { nil }
+  let(:s3_secret)        { nil }
+
+  let(:opts) do
+    { :uri_prefix       => uri_prefix,
+      :path_prefix      => path_prefix,
+      :resource_dir     => resource_dir,
+      :phantom_bin_path => phantom_bin_path,
+      :s3_key           => s3_key,
+      :s3_bin           => s3_bin,
+      :s3_secret        => s3_secret
+    }
+  end
+
+
+    # def js_file
+
+
+  subject { Shutterbug::Configuration.new(opts) }
+
+  describe "#fs_path_for(filename)" do |variable|
+    it "should return <resource_dir>/phantom_<sha>.extension" do
+      subject.fs_path_for("f208004.png").should == "resource_dir/phantom_f208004.png"
+    end
+  end
+
+  describe "base_url" do
+    let(:post)    { {}  }
+    let(:referrer){ nil }
+    let(:req)     { mock(:POST => post, :referrer => referrer, :scheme => "http", :host_with_port => "fake.com:80")}
+
+    describe "without explict base_url or a referrer" do
+      it "should use defaults" do
+        subject.base_url(req).should == "http://fake.com:80"
+      end
+    end
+    describe "with a referrer" do
+      let(:referrer) { "http://referrer.com/scuba.html"}
+      it "should use the referrer" do
+        subject.base_url(req).should == "http://referrer.com/scuba.html"
+      end
+    end
+    describe "with a POST param" do
+      let(:post)  { {'base_url' => "http://base_url.used.com/"} }
+      it "should use the POST param" do
+        subject.base_url(req).should == "http://base_url.used.com/"
+      end
+    end
+  end
+
+
+
+  describe "use_s3?" do
+    describe "with no S3 information" do
+      its(:use_s3?) { should be_false }
+    end
+
+    describe "when s3_bin is specified" do
+      let(:s3_bin)  { "bin" }
+      its(:use_s3?) { should be_false}
+
+      describe "when s3_key is specified" do
+        let(:s3_key)  { "key" }
+        its(:use_s3?) { should be_false}
+
+        describe "when s3_secret is specig" do
+          let(:s3_secret) { "secret" }
+          its(:use_s3?)   { should be_true}
+        end
+      end
+    end
+  end
+
+
+end

data/spec/shutterbug/convert_handler_spec.rb

@@ -0,0 +1,29 @@
+require 'shared_examples_for_handlers'
+describe Shutterbug::Handlers::ConvertHandler do
+  let(:mock_post) do
+    mock(:POST => {},
+      :referrer => nil,
+      :scheme => nil,
+      :host_with_port => nil)
+  end
+  let(:req) { mock_post }
+
+  it_behaves_like "a request handler" do
+    let(:req) { mock_post }
+  end
+
+  describe "calling phantom" do
+    let(:mock_results) { mock }
+    let(:rackapp) { mock(:good_response => true )}
+    let(:env)     { mock }
+    let(:fake_file)   { mock(:filename => "blub", :url => "glub")}
+    let(:mock_fantom) { mock(:cache_key => "1", :html_file => fake_file, :png_file => fake_file) }
+    before(:each) do
+      Shutterbug::PhantomJob.stub!(:new => mock_fantom)
+    end
+    it "should invoke phantom" do
+      mock_fantom.should_receive(:rasterize).and_return(mock_results)
+      subject.handle(rackapp,req,env)
+    end
+  end
+end

data/spec/shutterbug/file_storage_spec.rb

@@ -0,0 +1,5 @@
+require 'shared_examples_for_storage'
+describe Shutterbug::Storage::FileStorage do
+  it_behaves_like "a storage provider" do
+  end
+end

data/spec/shutterbug/html_file_handler_spec.rb

@@ -0,0 +1,10 @@
+require 'shared_examples_for_file_handlers'
+require 'shared_examples_for_handlers'
+describe Shutterbug::Handlers::FileHandlers::HtmlFile do
+  it_behaves_like "a file handler" do
+    let(:req) { mock(:path => "/shutterbug/get_html/foobar.html") }
+  end
+  it_behaves_like "a request handler" do
+    let(:req) { mock(:path => "/shutterbug/get_html/foobar.html") }
+  end
+end

data/spec/shutterbug/js_file_handler_spec.rb

@@ -0,0 +1,4 @@
+require 'shared_examples_for_handlers'
+describe Shutterbug::Handlers::JsFileHandler do
+  it_behaves_like "a request handler"
+end

data/spec/shutterbug/png_file_handler_spec.rb

@@ -0,0 +1,10 @@
+require 'shared_examples_for_file_handlers'
+require 'shared_examples_for_handlers'
+describe Shutterbug::Handlers::FileHandlers::PngFile do
+  it_behaves_like "a file handler" do
+    let(:req) { mock(:path => "/shutterbug/get_png/foobar.png") }
+  end
+  it_behaves_like "a request handler" do
+    let(:req) { mock(:path => "/shutterbug/get_png/foobar.png") }
+  end
+end

data/spec/shutterbug/rackapp_spec.rb

@@ -1,17 +1,22 @@
 require 'rack'
+require 'rack/test'
+
 RSpec::Matchers.define :be_happy_response do |filetype|
   match do |actual|
     actual[0] == 200 || actual[3] == filetype
   end
 end
 
+RSpec::Matchers.define :be_redirect_response do |url|
+  match do |actual|
+    actual[0] == 200 || actual[1]["Location"] == url
+  end
+end
+
 describe Shutterbug::Rackapp do
-  let(:sha)     { "542112e"                          }
-  let(:size)    { 200                                }
-  let(:rackfile){ mock :fackfile, :size => size      }
-  let(:service) { mock :service                      }
-  let(:app)     { mock :app                          }
-  let(:config)  { Shutterbug::Configuration.instance }
+  include Rack::Test::Methods
+
+  let(:config)    { Shutterbug::Configuration.instance }
 
   let(:post_data) do
     {
@@ -23,61 +28,64 @@ describe Shutterbug::Rackapp do
     }
   end
 
-  subject { Shutterbug::Rackapp.new(app) }
+  let(:app) do
+    Shutterbug::Rackapp.new  do |config|
+      config.uri_prefix   = "http://localhost:9292"
+      config.path_prefix  = "/shutterbug"
+    end
+  end
 
-  before(:each) do
-    Shutterbug::Service.stub!(:new => service)
+  let(:filename)  { "filename" }
+  let(:url)       { "url_to_file" }
+
+  let(:mock_file)  do
+    mock({
+      :get_content => "content",
+      :filename => filename,
+      :url => url
+    })
   end
 
-  describe "#do_convert" do
-    let(:req)       { mock :req, :POST => post_data}
-    it "should return a valid image url" do
-      service.should_receive(:convert).and_return(sha)
-      (resp_code,headers,content) = subject.do_convert(req)
-      resp_code.should == 200
-      headers['Content-Type'].should == 'text/plain'
-      content[0].should match /^<img src='[^']+'[^>]+>$/
-      headers['Content-Length'].should == content[0].size.to_s
-    end
+  let(:test_storage) { mock({ :new => mock_file         })}
+
+  before(:each) do
+    config.stub!(:storage => test_storage)
   end
 
-  describe "rounting requests in #call" do
-    let(:path) { 'bogus'                   }
-    let(:req)  { mock(:req, :path => path) }
-    before(:each) do
-      Rack::Request.stub!(:new).and_return(req)
-    end
+  describe "routing requests in #call" do
 
-    describe "convert route" do
-      let(:path)           { config.convert_path    }
-      let(:image_response) { mock :image_response               }
-      it "should route #do_convert" do
-        subject.should_receive(:do_convert, :with => req).and_return image_response
-        subject.call(mock).should == image_response
+    describe "do_convert route" do
+      it "should return a valid image url" do
+        get "/shutterbug/make_snapshot/", post_data
+        last_response.should be_ok
+        last_response.headers['Content-Type'].should match 'text/plain'
+        last_response.body.should match(/^<img src='url_to_file'[^>]+>$/)
       end
     end
 
     describe "get png route" do
-      let(:path) { config.png_path(sha) }
       it "should route #do_get_png" do
-        service.should_receive(:get_png_file, :with => sha).and_return rackfile
-        subject.call(mock).should be_happy_response('image/png')
+        Shutterbug::Configuration.instance.stub!(:storage => test_storage)
+        get "/shutterbug/get_png/filename.png"
+        last_response.should be_ok
+        last_response.headers['Content-Type'].should match 'image/png'
       end
     end
 
     describe "get html route" do
-      let(:path) { config.html_path(sha) }
       it "should route #do_get_html" do
-        service.should_receive(:get_html_file, :with => sha).and_return rackfile
-        subject.call(mock).should be_happy_response('text/html')
+
+        get "/shutterbug/get_html/filename.html"
+        last_response.should be_ok
+        last_response.headers['Content-Type'].should match 'text/html'
       end
     end
 
-    describe "get shutterbug javascipt route" do
-      let(:path) { config.js_path }
+    describe "get shutterbug.js javascipt route" do
       it "should route #do_get_shutterbug" do
-        service.should_receive(:get_shutterbug_file).and_return rackfile
-        subject.call(mock).should be_happy_response('application/javascript')
+        get "/shutterbug/shutterbug.js"
+        last_response.should be_ok
+        last_response.headers['Content-Type'].should match 'application/javascript'
       end
     end