spraycan 1.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c87eb1997c18476e5f7e5f3995863cff6e91173
+  data.tar.gz: f4f3137f02a414b31e554d4ddf8c97503f7202dc
+SHA512:
+  metadata.gz: 1b37960630ea84edabeddcbbcfa51d9de2a4c62d348cc6891e42f47bf2d9bed3433ad724c1e957f362bd6d9fe977ac7c356d16ceea02cbaac88190dc7ba995ee
+  data.tar.gz: 9a8c8beab9b20160b59f963f9b8a8b1f569a2237330996d00c065e1c4c9e6365a62756d964f9b12124ffd416999de4ab6241a59055ff563fb7d1140964265ce9

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/.rspec

@@ -0,0 +1,5 @@
+--color
+--format progress
+--order random
+--profile 5
+--require spec_helper

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gem 'rake'
+gem 'bottle',       :git => 'git://github.com/square-circle-triangle/bottle.git', :ref => 'master'
+gem 'publisher-s3', :git => 'git@bitbucket.org:squarecircletriangle/publisher-s3.git', :ref => 'master'
+gemspec

data/README.md

@@ -0,0 +1,20 @@
+# Spraycan
+
+## Development
+
+### Setup
+
+Spraycan relies on a few installed libraries to run:
+
+- imagemagick
+- ghostscript
+
+On OS X, installing them via `brew` is easiest:
+
+    > brew install imagemagick --build-from-source
+    > brew install ghostscript
+
+### Ruby version compatibility
+
+- Ruby v1.9 for Spraycan versions < v1.1
+- Ruby v2.1 for Spraycan versions >= v1.1

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace :ci do
+  task :tests => :spec
+end

data/bin/spraycan

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'spraycan'
+require 'optparse'
+STDOUT.sync = true
+
+options = {
+    background: false,
+    broker:     '127.0.0.1',
+    env:        'development',
+    queue_name: 'blocks.spraycan'
+}
+
+OptionParser.new do |opts|
+  opts.banner = <<-BANNER
+Spraycan handles images resizing & processing requests
+
+Usage: #{__FILE__} [options]
+
+Options are:
+BANNER
+
+  opts.separator ''
+
+  opts.on('-b', '--broker=HOST', String,
+          'The address of the amqp broker to connect to',
+          "Default: #{options[:broker]}") { |b| options[:broker] = b }
+
+  opts.on('-q', '--queue=queue_name', String,
+          'Specify which queue to listen to',
+          "Default: #{options[:queue_name]}") { |q| options[:queue_name] = q }
+
+  opts.on('-e', '--env=environment', String,
+          'Set the environment to run in',
+          "Default: #{options[:env]}") { |e| options[:env] = e }
+
+  opts.on('-D', '--background',
+          'Run campaigner in the background.') { |b| options[:background] = b }
+
+  opts.on('-h', '--help', 'Show this help message.') { puts opts; exit }
+end.parse!(ARGV)
+
+if options[:background]
+  require 'daemons'
+  Daemons.daemonize(app_name: 'spraycan', dir_mode: :normal, dir: '/var/run/campaigner')
+end
+
+Spraycan.run(options)

data/draw_test.rb

@@ -0,0 +1,17 @@
+require "rmagick"
+include Magick
+
+img = Image.new(1024, 1024) do
+  self.background_color = 'blue'
+end
+
+txt = Draw.new
+img.annotate(txt, 0, 0, 0, 0, "In ur Railz, annotatin ur picz.") do
+  txt.gravity = Magick::SouthGravity
+  txt.pointsize = 25
+  txt.stroke = "#000000"
+  txt.fill = "#ffffff"
+  txt.font_weight = Magick::BoldWeight
+end
+img.format = "png"
+File.open("/tmp/img.png", "w") { |f| f << img.to_blob }

data/lib/core_ext/magick.rb

@@ -0,0 +1,27 @@
+module Magick
+  class Image
+    SCT_CMYK_ICC = File.dirname(__FILE__) + '/profiles/cmyk-profile.icc'
+    SCT_SRGB_ICC = File.dirname(__FILE__) + '/profiles/srgb-profile.icc'
+
+    def ensure_rgb!
+      if rgb?
+        strip!
+      elsif cmyk?
+        add_profile SCT_CMYK_ICC if color_profile == nil
+        add_profile SCT_SRGB_ICC
+      else
+        puts 'unkown colorspace!'
+      end
+    end
+
+    private
+
+    def rgb?
+      colorspace == Magick::RGBColorspace || colorspace == Magick::SRGBColorspace
+    end
+
+    def cmyk?
+      colorspace == Magick::CMYKColorspace
+    end
+  end
+end

data/lib/publisher_s3.rb

@@ -0,0 +1,8 @@
+require 'publisher/s3'
+
+Publisher::S3.configure do |config|
+  config.access_key    = ENV['S3_ACCESS_KEY']
+  config.access_secret = ENV['S3_SECRET_KEY']
+  config.bucket_name   = ENV['S3_ASSETS_BUCKET_NAME']
+  config.default_host  = ENV['S3_DEFAULT_HOST']
+end

data/lib/safe_call.rb

@@ -0,0 +1,13 @@
+module SafeCall
+
+  def safe_call
+    begin
+      yield 
+    rescue Errno::ECONNRESET
+      i ||= 0
+      i += 1
+      retry if i < 3
+    end
+  end
+
+end

data/lib/spraycan.rb

@@ -0,0 +1,11 @@
+require 'aws/s3'
+require 'bottle'
+require 'core_ext/magick'
+require 'publisher_s3'
+require 'safe_call'
+
+require 'spraycan/base'
+require 'spraycan/rmagick'
+require 'spraycan/version'
+require 'spraycan/workers/manipulate'
+require 'spraycan/workers/previews'

data/lib/spraycan/base.rb

@@ -0,0 +1,11 @@
+module Spraycan
+  def self.run(opts={})
+    start(opts[:env])
+    server = Bottle::Server.new(opts[:queue_name], { :host => opts[:broker] })
+    server.poll
+  end
+
+  def self.start(env)
+    @@env = env.to_sym
+  end
+end

data/lib/spraycan/rmagick.rb

@@ -0,0 +1,100 @@
+require 'RMagick'
+
+module Spraycan
+
+  class Rmagick
+    VALID_OUTPUT_FORMATS = %w(JPEG PNG JPG GIF)
+
+    def resize(image, width, height = nil)
+      width, height = calculate_dimensions(image, width) unless height
+
+      process(image) do
+        change_geometry("#{width}x#{height}") { |cols, rows, image| image.resize!(cols, rows) }
+      end
+    end
+
+    def crop(image, tl_x, tl_y, br_x, br_y)
+      process image do
+        crop!(tl_x, tl_y, br_x, br_y)
+      end
+    end
+
+    def crop_resize(image, width, height = nil)
+      width, height = calculate_dimensions(image, width) unless height
+
+      process image do
+        crop_resized!(width, height)
+      end
+    end
+
+    # previews => { :very_small => { :dimensions => 40, :target => "/tmp/spraycan_spec/v_small.thumbnail.image.png" },
+    def previews(image, previews)
+      previews.each_value do |preview|
+        if preview.has_key?(:dimensions)
+          preview.merge!(crop_resize(image, preview.delete(:dimensions)))
+        else
+          preview.merge!(process(image))
+        end
+      end
+
+      previews.tap do |obj|
+        obj[:original] = dimensions(image)
+      end
+    end
+
+    def exif_data(image)
+      data = Magick::Image.from_blob(image).first.get_exif_by_entry
+      data.inject({}) { |m, exif_entry| m[exif_entry[0]] = exif_entry[1]; m }
+    end
+
+    def resized_crop_mask(image, crop, size)
+      process(image) do
+        resize!(size[:width], size[:height]) if size[:width] > 0 && size[:height] > 0
+        crop!(crop[:x], crop[:y], crop[:width], crop[:height], true) # pass true to clear offset info
+      end
+    end
+
+    protected
+
+    def process(image, &block)
+      img = Magick::Image.from_blob(image).first
+      img.instance_eval &block if block_given?
+      img.ensure_rgb!
+      img.format = get_format(image) # ensure that resized output is a JPEG
+
+      {
+          image:  img.to_blob,
+          width:  img.columns,
+          height: img.rows,
+          format: img.format
+      }
+    end
+
+    def get_format(image_data)
+      current_format = Magick::Image.from_blob(image_data).first.format
+      VALID_OUTPUT_FORMATS.include?(current_format) ? current_format : 'JPEG'
+    end
+
+    def dimensions(image_data)
+      image = Magick::Image.from_blob(image_data).first
+      { width: image.columns, height: image.rows }
+    end
+
+    def calculate_dimensions(image_data, size)
+      image = Magick::Image.from_blob(image_data).first
+      return image.columns, image.rows unless clipping_required?(image, size)
+
+      ratio = image.columns.to_f / image.rows.to_f
+
+      return [size, size.to_f / ratio] if ratio > 1 # Landscape
+      return [ratio * size, size] if ratio < 1      # Portrait
+
+      [size, size]                                  # Square
+    end
+
+    def clipping_required?(image, size)
+      (image.columns > size) || (image.rows > size)
+    end
+  end
+
+end

data/lib/spraycan/version.rb

@@ -0,0 +1,3 @@
+module Spraycan
+  VERSION = '1.1.3'
+end

data/lib/spraycan/workers/image.rb

@@ -0,0 +1,11 @@
+module Spraycan
+  class Image< Bottle::Foreman
+    def process(payload)
+      return failure("Image payload expected a hash, got #{payload.class.to_s}.") unless payload.is_a?(Hash)
+      success({})
+    rescue => e
+      Bugsnag.notify(e)
+      failure("Fatal error handling image: #{e.message}")
+    end
+  end
+end

data/lib/spraycan/workers/manipulate.rb

@@ -0,0 +1,40 @@
+module Spraycan
+  module Workers
+
+    class Manipulate < Bottle::Foreman
+      def process(payload)
+        puts "Starting Manipulate#process. Payload - #{payload.inspect}\n"
+
+        crop    = payload[:crop]
+        size    = payload[:size]
+        s3_path = payload[:s3_path]
+
+        return failure('s3_path must be specified') unless s3_path
+        return failure('crop not set') unless crop
+        return failure('size not set') unless size
+
+        image = get_image(s3_path)
+
+        response = Rmagick.new.resized_crop_mask(image, crop, size)
+
+        save_to_cloud(response[:image], s3_path)
+
+        GC.start #free the memory
+        return success({})
+      rescue => e
+        return failure 'Fatal error handling image: ' + e.message
+      end
+
+      def save_to_cloud(image, s3_path)
+        Publisher::S3::Upload.upload(image, s3_path)
+      end
+
+      def get_image(image_path)
+        Publisher::S3::Download.file_content(image_path)
+      rescue
+        raise "Failed to download #{image_path} from S3"
+      end
+    end
+
+  end
+end

data/lib/spraycan/workers/previews.rb

@@ -0,0 +1,47 @@
+module Spraycan
+  module Workers
+
+    class Previews < Bottle::Foreman
+      def process(payload)
+        puts "Starting Previews#process. Payload - #{payload.inspect}\n"
+
+        return failure("Image payload expected a hash, got #{payload.class.to_s}.") unless payload.is_a?(Hash)
+
+        s3_path  = payload[:s3_path]
+        previews = payload[:previews]
+
+        return failure('s3_path must be specified') unless s3_path
+        return failure('previews is not a hash') unless previews.is_a?(Hash)
+
+        image = get_image(s3_path)
+
+        response = Rmagick.new.previews(image, previews)
+
+        sizes = {}
+        response.each do |k, v|
+          sizes[k] = [v[:width], v[:height]]
+
+          next if k == :original
+          save_to_cloud(response[k][:image], response[k][:s3_path])
+          v.delete :image
+        end
+
+        GC.start #free the memory
+        success({ :sizes => sizes })
+      rescue => e
+        failure("Fatal error handling image: #{e.message}")
+      end
+
+      def save_to_cloud(image, s3_path)
+        Publisher::S3::Upload.upload(image, s3_path)
+      end
+
+      def get_image(image_path)
+        Publisher::S3::Download.file_content(image_path)
+      rescue
+        raise "Failed to download #{image_path} from S3"
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'bundler'
+Bundler.setup(:default, :test)
+
+require 'spraycan'
+require 'tmpdir'
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |f| require f }
+
+def write_test_image(path, width=1000, height=1000, format='png')
+  img = Magick::Image.new(width, height) do
+    self.background_color = 'blue'
+  end
+
+  txt = Magick::Draw.new
+  img.annotate(txt, 0, 0, 0, 0, 'In ur Railz, annotatin ur picz.') do
+    txt.gravity     = Magick::SouthGravity
+    txt.pointsize   = 25
+    txt.stroke      = '#000000'
+    txt.fill        = '#ffffff'
+    txt.font_weight = Magick::BoldWeight
+  end
+  img.format = format
+  File.open(path, 'w') { |f| f << img.to_blob }
+end

data/spec/spraycan/rmagick_spec.rb

@@ -0,0 +1,217 @@
+describe Spraycan::Rmagick do
+
+  before do
+    @image = 'image'
+    @columns = 1500; @rows = 1000
+    @blob = 'blob'
+
+    @rm_image = double(Object)
+    @rm_image.stub(:change_geometry).and_return
+    @rm_image.stub(:crop!).and_return
+    @rm_image.stub(:crop_resized!).and_return
+    @rm_image.stub(:resize!).and_return
+    @rm_image.stub(:ensure_rgb!).and_return
+    @rm_image.stub(:to_blob).and_return(@blob)
+    @rm_image.stub(:format).and_return('JPEG')
+    @rm_image.stub(:format=).and_return('JPEG')
+    @rm_image.stub(:columns).and_return(@columns)
+    @rm_image.stub(:rows).and_return(@rows)
+    Magick::Image.stub(:from_blob).and_return([@rm_image])
+
+    @processor = described_class.new
+  end
+
+  describe 'when resizing' do
+
+    it 'should auto calculate width/height when passed a single value' do
+      Magick::Image.should_receive(:from_blob).and_return([@rm_image])
+      @processor.should_receive(:calculate_dimensions).with(@image, 300).and_return([300,200])
+
+      @processor.resize @image, 300
+    end
+
+    it 'should preprocess images before resizing' do
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:change_geometry).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should convert images to rgb if required' do
+      @rm_image.should_receive(:ensure_rgb!).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).and_return('blob')
+      @processor.resize(@image, 300, 200).should == { :format => 'JPEG', :image => 'blob', :height => 1000, :width => 1500 }
+    end
+
+  end
+
+  describe 'when cropping' do
+
+    it 'should preprocess images before cropping' do
+      @processor.crop @image, 10, 10, 100, 100
+    end
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:crop!).and_return
+      @processor.crop @image, 10, 10, 100, 100
+    end
+
+    it 'should convert images to rgb if required' do
+      @rm_image.should_receive(:ensure_rgb!).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).and_return('blob')
+      @processor.crop(@image, 10, 10, 100, 100).should == { :format => 'JPEG', :image => 'blob', :height => 1000, :width => 1500 }
+    end
+
+  end
+
+  describe 'when performing a resized crop' do
+
+    it 'should preprocess images before resizing/cropping' do
+      @processor.crop_resize @image, 75, 75
+    end
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:crop_resized!).and_return
+      @processor.crop_resize @image, 75, 75
+    end
+
+    it 'should convert images to rgb if required' do
+      @rm_image.should_receive(:ensure_rgb!).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).and_return('blob')
+      @processor.crop_resize(@image, 75, 75).should == { :format => 'JPEG', :image => 'blob', :height => 1000, :width => 1500 }
+    end
+
+  end
+
+  describe 'when generating previews' do
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:crop_resized!).twice.and_return
+      @processor.previews @image, { :small => {:dimensions => 200}, :large => {:dimensions => 500} }
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).twice.and_return('blob')
+      @processor.previews(@image, { :small => {:dimensions => 1000}, :large => {:dimensions => 500} }).should == {  :small=> { :format => 'JPEG', :height => 1000, :width => 1500, :image => 'blob' }, :large=> { :format => 'JPEG', :height => 1000, :width => 1500, :image => 'blob' }, :original => {:width => 1500, :height => 1000} }
+    end
+
+  end
+  
+  describe 'crop_and_resize' do
+    
+    it 'should return an image with the specified sizes' do
+      @processor.resized_crop_mask(@image, {:x => 0, :y => 0, :width => 800, :height => 800 }, { :width => 2890, :height => 1940 }).should == {
+      	:format => 'JPEG', :image => 'blob', :width => 1500, :height => 1000}
+      
+    end
+    
+    it 'should return an image cropped to the crop marks' do
+      @rm_image.should_receive(:crop!).with(0,20,800,900, true).once
+      @processor.resized_crop_mask(@image, {:x => 0, :y => 20, :width => 800, :height => 900 }, { :width => 2890, :height => 1940 }).should == {
+      	:format => 'JPEG', :image => 'blob', :width => 1500, :height => 1000}
+    end 
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:resize!).with(2890,1940).once
+      @processor.resized_crop_mask(@image, {:x => 0, :y => 0, :width => 800, :height => 800 }, { :width => 2890, :height => 1940 }).should == {
+      	:format => 'JPEG', :image => 'blob', :width => 1500, :height => 1000}
+    end  
+  end
+  
+  describe 'exif_data' do
+    it 'should return a hash of exif data for the image' do
+      @rm_image.should_receive(:get_exif_by_entry).once.and_return([['Make', 'Canon'], ['ShutterSpeedValue', '189/32']])
+      @processor.exif_data(@image).should == { 'Make' => 'Canon', 'ShutterSpeedValue' => '189/32' }
+    end
+  end
+   
+  describe 'get_format' do
+	
+	described_class::VALID_OUTPUT_FORMATS.each do |valid_format|
+	  	it "should not change the image format if it is a #{valid_format}" do
+			@rm_image.should_receive(:format).and_return(valid_format)
+			@processor.send(:get_format, @rm_image).should == valid_format
+		end
+	end
+
+	it 'should change the format to JPEG if a non valid return format is found' do
+		['TIF', 'TIFF', 'PDF'].each do |bad_format|
+			@rm_image.should_receive(:format).and_return(bad_format)
+			@processor.send(:get_format, @rm_image).should == 'JPEG' 
+		end
+	end
+  end
+
+
+  describe 'dimension calculation' do
+
+    it 'should automatically recognize images in portrait mode' do
+      @processor.send(:calculate_dimensions, @rm_image, 300).should == [300,200]
+    end
+
+    it 'should automatically recognize images in landscape mode' do
+      @rm_image.stub(:columns).and_return(1000)
+      @rm_image.stub(:rows).and_return(1500)
+      @processor.send(:calculate_dimensions, @rm_image, 300).should == [200,300]
+    end
+
+    it 'should automatically clip resizes if they are larger than the original' do
+      @processor.send(:calculate_dimensions, @rm_image, 2000).should == [1500,1000]
+    end
+
+  end
+
+end
+
+describe Magick::Image, 'when created' do
+
+  before do
+    @image = Magick::Image.new(200, 100)
+  end
+
+  it 'should be able to convert the profile to srgb when requested' do
+    @image.should respond_to(:ensure_rgb!)
+  end
+
+end
+
+describe Magick::Image, 'when converting images to sRGB' do
+
+  before do
+    @image = Magick::Image.new(200, 100)
+    @image.stub(:add_profile).and_return
+  end
+
+  it 'should return if the image is already in sRGB colour space' do
+    @image.colorspace = Magick::RGBColorspace
+    @image.should_not_receive(:add_profile)
+    @image.ensure_rgb!
+  end
+
+  it 'should add a CMYK profile if the image does not have a profile and is in CMYK colour space' do
+    @image.colorspace = Magick::CMYKColorspace
+    @image.should_receive(:add_profile).twice.and_return
+    @image.ensure_rgb!
+  end
+
+  it 'should add a sRGB profile if the image is in CMYK colour space' do
+    @image.colorspace = Magick::CMYKColorspace
+    @image.should_receive(:add_profile).with(Magick::Image::SCT_SRGB_ICC).and_return
+    @image.ensure_rgb!
+  end
+
+end

data/spec/spraycan/workers/manipulate_spec.rb

@@ -0,0 +1,53 @@
+require 'tmpdir'
+
+include Spraycan::Workers
+
+describe Spraycan::Workers::Manipulate do
+  before do
+    tmpdir = Dir.mktmpdir
+    image_path = File.join(tmpdir, 'image.png')
+    write_test_image(image_path, 1280, 800)
+
+    @payload = {
+        :crop => {:x=>497, :y=>228, :width=>217, :height=>168},
+        :size => {:width=>921, :height=>576}, 
+        :s3_path => 'some/key'
+    }
+    
+    Publisher::S3::Upload.stub(:upload)
+    file_content = File.read(image_path)
+    Publisher::S3::Download.stub(:file_content).and_return(file_content)
+  end
+
+  it 'should require s3_path' do
+    @payload.delete :s3_path
+    Manipulate.new.process(@payload).should fail_with 's3_path must be specified'
+  end
+
+  it 'should require a valid image' do
+    Publisher::S3::Download.stub(:file_content).with(@payload[:s3_path]).and_raise('Error')
+    Manipulate.new.process(@payload).should fail_with 'Fatal error handling image: Failed to download some/key from S3'
+  end
+
+  it 'should require crop' do
+    @payload.delete :crop
+    Manipulate.new.process(@payload).should fail_with 'crop not set'
+  end
+
+  it 'should require size' do
+    @payload.delete :size
+    Manipulate.new.process(@payload).should fail_with 'size not set'
+  end
+
+  it 'should fail correctly' do
+    manipulate = Manipulate.new
+    manipulate.stub(:get_image).and_raise('Some bad thing happened')
+    manipulate.process(@payload).should fail_with 'Fatal error handling image: Some bad thing happened'
+  end
+  
+  it 'should save manipulated image to the cloud' do
+    Publisher::S3::Upload.should_receive(:upload)
+    Manipulate.new.process(@payload)
+  end
+  
+end

data/spec/spraycan/workers/previews_spec.rb

@@ -0,0 +1,78 @@
+include Spraycan::Workers
+
+describe Spraycan::Workers::Previews do
+  before do
+    tmpdir = Dir.mktmpdir
+    image_path = File.join(tmpdir, 'image.png')
+    write_test_image(image_path, 1280, 800)
+    @payload = {
+        :previews => {
+            :very_small=>
+                {:dimensions=>40,
+                 :target=>File.join(tmpdir, 'v_small.thumbnail.image.png')},
+            :small=>
+                {:dimensions=>135,
+                 :target=>File.join(tmpdir, 'small.thumbnail.image.png')},
+            :preview=>
+                {:dimensions=>450,
+                 :target=>File.join(tmpdir, 'preview.thumbnail.image.png')},
+            :large_preview=>
+                {:dimensions=>1100,
+                 :target=>File.join(tmpdir, 'large_preview.thumbnail.image.png')}
+        },
+        :s3_path => 'some/key'
+    }
+    Publisher::S3::Upload.stub(:upload)
+    file_content = File.read(image_path)
+    Publisher::S3::Download.stub(:file_content).and_return(file_content)
+  end
+
+  it 'should fail correctly' do
+    preview = Previews.new
+    preview.stub(:get_image).and_raise('Some bad thing happened')
+  
+    preview.process(@payload).should fail_with 'Fatal error handling image: Some bad thing happened'
+  end
+
+  describe 'payload' do
+    it 'should fail unless payload is a hash' do
+      Previews.new.process([]).should fail_with 'Image payload expected a hash, got Array.'
+    end
+    
+    it 'should require a s3 path' do
+      @payload.delete(:s3_path)
+      Previews.new.process(@payload).should fail_with 's3_path must be specified'
+    end
+  
+    it 'should require a valid image' do
+      Publisher::S3::Download.stub(:file_content).with(@payload[:s3_path]).and_raise('Error')
+      Previews.new.process(@payload).should fail_with "Fatal error handling image: Failed to download #{@payload[:s3_path]} from S3"
+    end
+  
+    it 'should require an hash of previews' do
+      @payload.delete :previews
+      Previews.new.process(@payload).should fail_with 'previews is not a hash'
+    end
+  
+  end
+
+  describe 'sizes response' do
+    it 'should return sizes correctly' do
+      Previews.new.process(@payload).should succeed_with({:sizes=>{:very_small=>[40, 25], :small=>[135, 84], :preview=>[450, 281], :large_preview=>[1100, 687], :original=>[1280, 800]}})
+    end
+  end
+  
+  it 'should create images in payload' do
+    @payload[:previews].each do |size, value|
+      next if size == :original
+      Publisher::S3::Upload.should_receive(:upload)
+    end
+    Previews.new.process(@payload)
+  end
+  
+  it 'should save each new crop image to the cloud' do
+    Publisher::S3::Upload.should_receive(:upload)
+    Previews.new.process(@payload)
+  end
+  
+end

data/spec/support/bottle_helper.rb

@@ -0,0 +1,14 @@
+RSpec::Matchers.define :fail_with do |expected|
+  match do |actual|
+    actual[:state] == 'error'
+    actual[:message] == expected
+  end
+end
+
+RSpec::Matchers.define :succeed_with do |expected|
+  match do |actual|
+    actual[:state] == 'success'
+    actual.delete(:state)
+    actual == expected
+  end
+end

data/spraycan.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib/', __FILE__)
+require 'spraycan/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'spraycan'
+  s.version     = Spraycan::VERSION
+  s.authors     = ['Nick Marfleet', 'Alan Harper']
+  s.email       = ['nick@sct.com.au']
+  s.homepage    = 'http://www.blocksglobal.com'
+  s.summary     = %q{Image processor for blocks}
+  s.description = s.summary + ' using the bottle messaging framework'
+
+  s.rubyforge_project = 'spraycan'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '~> 2.1.8'
+
+  s.add_development_dependency 'rspec', '~> 2.14.1'
+
+  s.add_runtime_dependency 'aws-s3'
+  s.add_runtime_dependency 'daemons'
+  s.add_runtime_dependency 'rmagick'
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: spraycan
+version: !ruby/object:Gem::Version
+  version: 1.1.3
+platform: ruby
+authors:
+- Nick Marfleet
+- Alan Harper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: aws-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Image processor for blocks using the bottle messaging framework
+email:
+- nick@sct.com.au
+executables:
+- spraycan
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/spraycan
+- draw_test.rb
+- lib/core_ext/magick.rb
+- lib/core_ext/profiles/cmyk-profile.icc
+- lib/core_ext/profiles/srgb-profile.icc
+- lib/publisher_s3.rb
+- lib/safe_call.rb
+- lib/spraycan.rb
+- lib/spraycan/base.rb
+- lib/spraycan/rmagick.rb
+- lib/spraycan/version.rb
+- lib/spraycan/workers/image.rb
+- lib/spraycan/workers/manipulate.rb
+- lib/spraycan/workers/previews.rb
+- spec/spec_helper.rb
+- spec/spraycan/rmagick_spec.rb
+- spec/spraycan/workers/manipulate_spec.rb
+- spec/spraycan/workers/previews_spec.rb
+- spec/support/bottle_helper.rb
+- spraycan.gemspec
+homepage: http://www.blocksglobal.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: 2.1.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: spraycan
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Image processor for blocks
+test_files:
+- spec/spec_helper.rb
+- spec/spraycan/rmagick_spec.rb
+- spec/spraycan/workers/manipulate_spec.rb
+- spec/spraycan/workers/previews_spec.rb
+- spec/support/bottle_helper.rb