img-kit 1.3.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06110885384e166f0c19be2cd296d9259c88487c
+  data.tar.gz: a5c794145d084b19878bf91625c23ed3cd0ab7af
+SHA512:
+  metadata.gz: 1fd97dddc1a97022742b2cb9f2638f8035d0f3bb712358faa9a57afbe17774ba74d7158527c42c60b5e1a14ffa83804d8fce3f15b6dec7b8cc00cf38a712b70b
+  data.tar.gz: c08b9f4b965e74d72a71809d53c428729ddc9666399220e79d7f1ae632ebc3c28e55a93009035b0670a65e8ede5ed35342c7a70263fe9b5bbdae2865c06c89d2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+test.sh
+.rvmrc
+vendor

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem "rake"
+  gem "rspec", "~> 2"
+  gem "rspec-core", "~> 2"
+  gem "mocha"
+  gem "rack"
+  gem "ruby-debug19", :platforms => :mri_19
+  gem "ruby-debug", :platforms => :mri_18
+end

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    img-kit (1.3.9.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.4)
+    diff-lcs (1.1.2)
+    linecache (0.46)
+      rbx-require-relative (> 0.0.4)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    mocha (0.9.12)
+    rack (1.3.0)
+    rake (0.9.2.2)
+    rbx-require-relative (0.0.5)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  img-kit!
+  mocha
+  rack
+  rake
+  rspec (~> 2)
+  rspec-core (~> 2)
+  ruby-debug
+  ruby-debug19

data/LICENSE

@@ -0,0 +1,22 @@
+This is a derivative work.
+
+Original Copyright (c) 2009 jdpace
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/POST_INSTALL

@@ -0,0 +1,12 @@
+******************************************************************
+
+Now install wkhtmltoimage binaries:
+Global: sudo `which imgkit` --install-wkhtmltoimage
+        rvmsudo imgkit --install-wkhtmltoimage
+(installs to default /usr/local/bin/wkhtmltoimage)
+
+inside RVM folder: export TO=`which imgkit | sed 's:/imgkit:/wkhtmltoimage:'` && imgkit --install-wkhtmltoimage
+(you'll have to configure the location of the binary if you do this!)
+
+(run imgkit --help to see more options)
+******************************************************************

data/README.md

@@ -0,0 +1,15 @@
+# IMGKit
+
+Cloned from [csquared](http://github.com/csquared/IMGKit) to fix these bugs:
+
+1. Don't **spawn** new `wkhtmltoimage` and continue execution: wait for them to terminate!
+
+2. Recognize that `TempFile` is a file.
+
+The problem with 1. was that, while `wkhtmltoimage` was still running, the
+(only partially) rendered image was being uploaded to S3, causing broken images.
+
+The problem with 2. was that, since `wkhtmltoimage` [does not work with HTML in STDIN](http://code.google.com/p/wkhtmltopdf/issues/detail?id=534),
+the HTML must be stored in a temporary file, and the original IMGKit thinks that
+[Tempfile instances are not files](https://github.com/csquared/IMGKit/blob/master/lib/imgkit/source.rb#L14).
+

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+Bundler.require
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+task :specs => :spec

data/bin/imgkit

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+require 'rbconfig'
+require 'open-uri'
+require 'imgkit/configuration'
+require 'imgkit/version'
+
+GOOGLE_CODE_URL = ENV['GOOGLE_CODE_URL'] || "http://code.google.com/p/wkhtmltopdf/downloads/list?can=1"
+
+def detect_architecture
+  case arch = Config::CONFIG['arch']
+  when /x86_64-linux/i
+    'amd64'
+  when /linux/i
+    'i386'
+  when /darwin/i
+    'OSX'
+  else
+    cant_find_binaries(arch)
+  end
+end
+
+def cant_find_binaries(arch)
+  puts "Sorry, I couldn't find the binary for your architecture (#{arch}) \n  at #{GOOGLE_CODE_URL}"
+  puts "Please go to that page, unzip the appropriate binary, and install"
+  exit(1)
+end
+
+def cleanup(install_to)
+  `rm -rf wkhtmltoimage*` rescue nil
+  `rm #{install_to}` rescue nil
+end
+
+def download_wkhtmltoimage(arch)
+  if ENV['BZIP'] 
+    download = "wkhtmltoimage-0.10.0_beta4-static-#{arch}.tar.bz2"
+    url = "http://wkhtmltopdf.googlecode.com/files/wkhtmltoimage-0.10.0_beta4-static-#{arch}.tar.bz2"
+  else
+    page = open(GOOGLE_CODE_URL).read
+    download = page.match(/href=".*name=(.*wkhtmltoimage-.*#{arch}.*?)&/) or cant_find_binaries(arch)
+    download = download[1]
+    url = "http://wkhtmltopdf.googlecode.com/files/#{download}"
+  end
+  puts "Downloading #{download} from #{url}"
+  
+  `curl #{url} > #{download}`
+  download
+end
+
+def install(download, arch, install_to)
+  puts "Installing #{download} to #{install_to}"
+  if download =~ /.tar.bz2$/
+    `tar xjvf #{download}`
+    `mv wkhtmltoimage #{install_to}`
+  elsif download =~ /.tar.lzma$/
+    raise "couldn't extract archive: lzcat not found" unless system("which lzcat > /dev/null 2>/dev/null")
+    puts "Warning: lzcat is broken on Ubuntu. Re-run with --use-bzip to install alternate version"
+    `lzcat #{download} | tar x`
+    `mv wkhtmltoimage-#{arch} #{install_to}`
+  else
+    `mv #{download} #{install_to}`
+  end
+  `chmod +x #{install_to}`
+end
+
+@command = Proc.new { puts "Nothing to do: use --help"}
+
+OptionParser.new do |parser|
+  parser.banner = "IMGKit\n\nOptions are:"
+
+  parser.on("--use-bzip", "Force bzip download for Ubuntu because lzcat is broken") do
+    ENV['BZIP'] = 'true'
+  end
+
+  parser.on("--install-wkhtmltoimage", "Install wkhtmltoimage binaries (TO=/usr/local/bin ARCHITECTURE=i386)") do
+    @command = Proc.new do
+      architecture = ENV['ARCHITECTURE'] || detect_architecture
+      install_to = ENV['TO'] ? ENV['TO']+'/wkhtmltoimage' : IMGKit.configuration.wkhtmltoimage
+      
+      Dir.chdir '/tmp'
+      
+      cleanup(install_to)
+      download = download_wkhtmltoimage(architecture)
+      install(download, architecture, install_to)
+    end
+  end
+
+  parser.on("--version", "Show Version.") do
+    @command = Proc.new do
+      puts IMGKit::VERSION
+    end
+  end
+
+  parser.on("-h", "--help", "Show this.") { puts parser; exit }
+end.parse!
+
+@command.call

data/imgkit.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "imgkit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "img-kit"
+  s.version     = IMGKit::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors = ["csquared"]
+  s.email = %q{christopher.continanza@gmail.com}
+  s.homepage    = "http://github.com/topspin/imgkit"
+  s.summary =  %q{HTML+CSS -> JPG}
+  s.description = %q{Uses wkhtmltoimage to create Images using HTML}
+  s.post_install_message = File.read('POST_INSTALL')
+
+  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"]
+end

data/lib/imgkit.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'open3'
+require 'imgkit/source'
+require 'imgkit/imgkit'
+require 'imgkit/configuration'
+require 'imgkit/version'

data/lib/imgkit/configuration.rb

@@ -0,0 +1,35 @@
+class IMGKit
+  class Configuration
+    attr_accessor :meta_tag_prefix, :wkhtmltoimage, :default_options, :default_format
+
+    def initialize
+      @meta_tag_prefix = 'imgkit-'
+      @default_options = {:height => 1000}
+      @default_format  = :jpg
+      @wkhtmltoimage ||= (defined?(Bundler::GemfileError) ? `bundle exec which wkhtmltoimage` : `which wkhtmltoimage`).chomp
+      @wkhtmltoimage = '/usr/local/bin/wkhtmltoimage' if @wkhtmltoimage.strip.empty?  # Fallback
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  # Configure IMGKit someplace sensible,
+  # like config/initializers/imgkit.rb
+  #
+  # @example
+  #   IMGKit.configure do |config|
+  #     config.wkhtmltoimage = '/usr/bin/wkhtmltoimage'
+  #   end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+
+  def self.configure
+    self.configuration
+    yield(configuration)
+  end
+end

data/lib/imgkit/imgkit.rb

@@ -0,0 +1,199 @@
+class IMGKit
+  KNOWN_FORMATS = [:jpg, :jpeg, :png, :tiff, :tif]
+
+  class NoExecutableError < StandardError
+    def initialize
+      msg  = "No wkhtmltoimage executable found at #{IMGKit.configuration.wkhtmltoimage}\n"
+      msg << ">> Install wkhtmltoimage by hand or try running `imgkit --install-wkhtmltoimage`"
+      super(msg)
+    end
+  end
+
+  class ImproperSourceError < StandardError
+    def initialize(msg)
+      super("Improper Source: #{msg}")
+    end
+  end
+
+  class CommandFailedError < RuntimeError
+    attr_reader :command, :stderr
+    def initialize(command, stderr)
+      @command = command
+      @stderr  = stderr
+      super("Command failed: #{command}: #{stderr}")
+    end
+  end
+
+  class UnknownFormatError < StandardError
+    def initialize(format)
+      super("Unknown Format: #{format}")
+    end
+  end
+
+  attr_accessor :source, :stylesheets
+  attr_reader :options
+
+  def initialize(url_file_or_html, options = {})
+    @source = Source.new(url_file_or_html)
+
+    @stylesheets = []
+
+    @options = IMGKit.configuration.default_options.merge(options)
+    @options.merge! find_options_in_meta(url_file_or_html) unless source.url?
+
+    raise NoExecutableError.new unless File.exists?(IMGKit.configuration.wkhtmltoimage)
+  end
+
+  def command
+    args = [executable]
+    args += normalize_options(@options).to_a.flatten.compact
+
+    if @source.html?
+      html_file = Tempfile.open ['file', '.html']
+      html_file.write @source.to_s
+      html_file.close
+      args << html_file.path
+    else
+      args << @source.to_s
+    end
+
+    args << '-' # Read IMG from stdout
+    args
+  end
+
+  def executable
+    default = IMGKit.configuration.wkhtmltoimage
+    return default if default !~ /^\// # its not a path, so nothing we can do
+    if File.exist?(default)
+      default
+    else
+      default.split('/').last
+    end
+  end
+
+  if Open3.respond_to? :capture3
+    def capture3(*opts)
+      Open3.capture3 *opts
+    end
+  else
+    # Lifted from ruby 1.9.2-p290 sources for ruby 1.8 compatibility
+    # and modified to work on 1.8
+    def capture3(*cmd, &block)
+      if Hash === cmd.last
+        opts = cmd.pop.dup
+      else
+        opts = {}
+      end
+
+      stdin_data = opts.delete(:stdin_data) || ''
+      binmode = opts.delete(:binmode)
+
+      Open3.popen3(*cmd) {|i, o, e|
+        if binmode
+          i.binmode
+          o.binmode
+          e.binmode
+        end
+        out_reader = Thread.new { o.read }
+        err_reader = Thread.new { e.read }
+        i.write stdin_data
+        i.close
+        [out_reader.value, err_reader.value]
+      }
+    end
+  end
+
+  def to_img(format = nil)
+    append_stylesheets
+    set_format(format)
+
+    result = `#{command.join ' '}`
+    result.force_encoding("ASCII-8BIT") if result.respond_to? :force_encoding
+
+    raise CommandFailedError.new(command.join(' '), '') if result.size == 0
+    result
+  end
+
+  def to_file(path)
+    format = File.extname(path).gsub(/^\./,'').to_sym
+    set_format(format)
+    File.open(path,'w:ASCII-8BIT') {|file| file << self.to_img}
+  end
+
+  def method_missing(name, *args, &block)
+    if(m = name.to_s.match(/^to_(\w+)/))
+      self.send(:to_img, m[1].to_sym)
+    else
+      super
+    end
+  end
+
+  protected
+
+    def find_options_in_meta(body)
+      imgkit_meta_tags(body).inject({}) do |found, tag|
+        name = tag.attributes["name"].sub(/^#{IMGKit.configuration.meta_tag_prefix}/, '').to_sym
+        found.merge(name => tag.attributes["content"])
+      end
+    end
+
+    def imgkit_meta_tags(body)
+      require 'rexml/document'
+      xml_body = REXML::Document.new(body)
+      found = []
+      xml_body.elements.each("html/head/meta") do |tag|
+        found << tag if tag.attributes['name'].to_s =~ /^#{IMGKit.configuration.meta_tag_prefix}/
+      end
+      found
+    rescue # rexml random crash on invalid xml
+      []
+    end
+
+    def style_tag_for(stylesheet)
+      "<style>#{stylesheet.respond_to?(:read) ? stylesheet.read : File.read(stylesheet)}</style>"
+    end
+
+    def append_stylesheets
+      raise ImproperSourceError.new('Stylesheets may only be added to an HTML source') if stylesheets.any? && !@source.html?
+
+      stylesheets.each do |stylesheet|
+        if @source.to_s.match(/<\/head>/)
+          @source.to_s.gsub!(/(<\/head>)/, style_tag_for(stylesheet)+'\1')
+        else
+          @source.to_s.insert(0, style_tag_for(stylesheet))
+        end
+      end
+    end
+
+    def normalize_options(options)
+      normalized_options = {}
+
+      options.each do |key, value|
+        next if !value
+        normalized_key = "--#{normalize_arg key}"
+        normalized_options[normalized_key] = normalize_value(value)
+      end
+      normalized_options
+    end
+
+    def normalize_arg(arg)
+      arg.to_s.downcase.gsub(/[^a-z0-9]/,'-')
+    end
+
+    def normalize_value(value)
+      case value
+      when TrueClass
+        nil
+      when Array
+        value
+      else
+        value.to_s
+      end
+    end
+
+    def set_format(format)
+      format = IMGKit.configuration.default_format unless format
+      @options.merge!(:format => format.to_s) unless @options[:format]
+      raise UnknownFormatError.new(format) unless KNOWN_FORMATS.include?(@options[:format].to_sym)
+    end
+end

data/lib/imgkit/source.rb

@@ -0,0 +1,27 @@
+class IMGKit
+
+  class Source
+
+    def initialize(url_file_or_html)
+      @source = url_file_or_html
+    end
+
+    def url?
+      @source.is_a?(String) && @source.match(/\Ahttp/)
+    end
+
+    def file?
+      @source.kind_of?(File) || @source.kind_of?(Tempfile)
+    end
+
+    def html?
+      !(url? || file?)
+    end
+
+    def to_s
+      file? ? @source.path : @source
+    end
+
+  end
+
+end

data/lib/imgkit/version.rb

@@ -0,0 +1,3 @@
+class IMGKit
+  VERSION = "1.3.9.1"
+end

data/spec/error_binary

@@ -0,0 +1,3 @@
+#!/bin/bash
+echo 'I have a problem' > /dev/stderr
+exit 1

data/spec/fixtures/example.css

@@ -0,0 +1 @@
+body { font-size: 20px; }

data/spec/fixtures/example.html

@@ -0,0 +1,5 @@
+<html>
+  <body>
+    <h1>Oh Hai!</h1>
+  </body>
+</html>

data/spec/imgkit_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+
+describe IMGKit do
+  context "initialization" do
+    it "should accept HTML as the source" do
+      imgkit = IMGKit.new('<h1>Oh Hai</h1>')
+      imgkit.source.should be_html
+      imgkit.source.to_s.should == '<h1>Oh Hai</h1>'
+    end
+
+    it "should accept a URL as the source" do
+      imgkit = IMGKit.new('http://google.com')
+      imgkit.source.should be_url
+      imgkit.source.to_s.should == 'http://google.com'
+    end
+
+    it "should accept a File as the source" do
+      file_path = File.join(SPEC_ROOT,'fixtures','example.html')
+      imgkit = IMGKit.new(File.new(file_path))
+      imgkit.source.should be_file
+      imgkit.source.to_s.should == file_path
+    end
+
+    it "should provide no default options" do
+    end
+
+    it "should set a default height" do
+      imgkit = IMGKit.new('<h1>Oh Hai</h1>')
+      imgkit.options.length.should be 1
+      imgkit.options[:height].should be 1000
+    end
+
+
+=begin
+    it "should default to 'UTF-8' encoding" do
+      imgkit = IMGKit.new('Captación')
+    end
+=end
+
+    it "should not have any stylesheet by default" do
+      imgkit = IMGKit.new('<h1>Oh Hai</h1>')
+      imgkit.stylesheets.should be_empty
+    end
+  end
+
+  context "command" do
+    it "should contstruct the correct command" do
+      imgkit = IMGKit.new('html')
+      imgkit.command[0].should include('wkhtmltoimage')
+      imgkit.command.should include('-')
+    end
+
+    it "should parse the options into a cmd line friedly format" do
+      imgkit = IMGKit.new('html', :quality => 75)
+      imgkit.command.should include('--quality')
+    end
+
+    it "will not include default options it is told to omit" do
+      imgkit = IMGKit.new('html')
+      imgkit = IMGKit.new('html', :disable_smart_shrinking => false)
+      imgkit.command.should_not include('--disable-smart-shrinking')
+    end
+    it "should encapsulate string arguments in quotes" do
+      imgkit = IMGKit.new('html', :header_center => "foo [page]")
+      imgkit.command[imgkit.command.index('--header-center') + 1].should == 'foo [page]'
+    end
+
+    it "should properly handle multi-part arguments" do
+      imgkit = IMGKit.new('html', :custom_header => ['User-Agent', 'some user agent'])
+      imgkit.command[imgkit.command.index('--custom-header') + 1].should == 'User-Agent'
+      imgkit.command[imgkit.command.index('--custom-header') + 2].should == 'some user agent'
+    end
+
+    it "read the source from a temporary file if it is html" do
+      imgkit = IMGKit.new('html')
+      imgkit.command[-2].should_not == '-'
+    end
+
+    it "specify the URL to the source if it is a url" do
+      imgkit = IMGKit.new('http://google.com')
+      imgkit.command[-2..-1].should == ['http://google.com', '-']
+    end
+
+    it "should specify the path to the source if it is a file" do
+      file_path = File.join(SPEC_ROOT,'fixtures','example.html')
+      imgkit = IMGKit.new(File.new(file_path))
+      imgkit.command[-2..-1].should == [file_path, '-']
+    end
+
+    it "should detect special imgkit meta tags" do
+      body = %{
+        <html>
+          <head>
+            <meta name="imgkit-page_size" content="Legal"/>
+            <meta name="imgkit-orientation" content="Landscape"/>
+            <meta name="imgkit-crop-h" content="900"/>
+          </head>
+        </html>
+      }
+      imgkit = IMGKit.new(body)
+      imgkit.command[imgkit.command.index('--page-size') + 1].should == 'Legal'
+      imgkit.command[imgkit.command.index('--orientation') + 1].should == 'Landscape'
+      imgkit.command[imgkit.command.index('--crop-h') + 1].should == '900'
+    end
+  end
+
+  context "#to_img(format = nil)" do
+    def filetype_of(img)
+      result = nil
+      tmpfile = Tempfile.new('imgkit')
+      File.open(tmpfile.path, 'w') { |f| f << img }
+      result = `file #{tmpfile.path}`
+      tmpfile.unlink()
+      result
+    end
+
+    it "should generate a IMG of the HTML" do
+      imgkit = IMGKit.new('html')
+      img = imgkit.to_img
+      filetype_of(img).should include('JPEG')
+    end
+
+    it "should generate an Image with a numerical parameter" do
+      imgkit = IMGKit.new('html', :quality => 50)
+      img = imgkit.to_img
+      filetype_of(img).should include('JPEG')
+    end
+
+    it "should generate an Image with a symbol parameter" do
+      imgkit = IMGKit.new('html', :username => 'chris')
+      img = imgkit.to_img
+      filetype_of(img).should include('JPEG')
+    end
+
+    it "should have the stylesheet added to the head if it has one" do
+      imgkit = IMGKit.new("<html><head></head><body>Hai!</body></html>")
+      css = File.join(SPEC_ROOT,'fixtures','example.css')
+      imgkit.stylesheets << css
+      imgkit.to_img
+      imgkit.source.to_s.should include("<style>#{File.read(css)}</style>")
+    end
+
+    it "should accept stylesheet as an object which responds to #read" do
+      imgkit = IMGKit.new("<html><head></head><body>Hai!</body></html>")
+      css = StringIO.new( File.read(File.join(SPEC_ROOT,'fixtures','example.css')) )
+      imgkit.stylesheets << css
+      imgkit.to_img
+      imgkit.source.to_s.should include("<style>#{css.string}</style>")
+    end
+
+    it "should prepend style tags if the HTML doesn't have a head tag" do
+      imgkit = IMGKit.new("<html><body>Hai!</body></html>")
+      css = File.join(SPEC_ROOT,'fixtures','example.css')
+      imgkit.stylesheets << css
+      imgkit.to_img
+      imgkit.source.to_s.should include("<style>#{File.read(css)}</style><html>")
+    end
+
+    it "should throw an error if the source is not html and stylesheets have been added" do
+      imgkit = IMGKit.new('http://google.com')
+      css = File.join(SPEC_ROOT,'fixtures','example.css')
+      imgkit.stylesheets << css
+      lambda { imgkit.to_img }.should raise_error(IMGKit::ImproperSourceError)
+    end
+
+    def set_wkhtmltoimage_binary(binary)
+      spec_dir = File.dirname(__FILE__)
+      IMGKit.configuration.should_receive(:wkhtmltoimage).at_least(1).times.and_return(File.join(spec_dir, binary))
+    end
+
+    it "should throw an error if the wkhtmltoimage command fails" do
+      set_wkhtmltoimage_binary 'error_binary'
+      imgkit = IMGKit.new('http://www.example.com')
+      lambda { imgkit.to_img }.should raise_error(IMGKit::CommandFailedError)
+    end
+
+    it "should be able to handle lots of error output" do
+      set_wkhtmltoimage_binary 'warning_binary'
+      imgkit = IMGKit.new("<html><body>Hai!</body></html>")
+      imgkit.to_img.should == "result\n"
+    end
+
+    context "when there is no format" do
+      it "should fallback to jpg" do
+        IMGKit.new("Hello, world").to_img.should be_a(:jpg)
+      end
+
+      context "when a default_format has been configured" do
+        before do
+          IMGKit.configure do |config|
+            config.default_format = :png
+          end
+        end
+
+        after do
+          IMGKit.configure do |config|
+            config.default_format = :jpg
+          end
+        end
+
+        it "should use the configured format" do
+          IMGKit.new("Oh hai!").to_img.should be_a(:png)
+        end
+      end
+    end
+
+    context "when format = :jpg" do
+      it "should create a jpg" do
+        IMGKit.new("Hello, world").to_img(:jpg).should be_a(:jpg)
+      end
+    end
+
+    context "when format is a known format" do
+      it "should create an image with that format" do
+        IMGKit::KNOWN_FORMATS.each do |format|
+          IMGKit.new("Hello, world").to_img(format).should be_a(format)
+        end
+      end
+    end
+
+    context "when format is unknown" do
+      it "should raise an UnknownFormatError" do
+        lambda { IMGKit.new("Hello, world").to_img(:blah) }.should raise_error(IMGKit::UnknownFormatError)
+      end
+    end
+  end
+
+  context "#to_<known_format>" do
+    IMGKit::KNOWN_FORMATS.each do |format|
+      describe "#to_#{format}" do
+        it "should create a #{format}" do
+          IMGKit.new("Hello").send("to_#{format}").should be_a(format)
+        end
+      end
+    end
+  end
+
+  context "#to_<unkown_format>" do
+    it "should raise and UnknownFormatError" do
+      lambda { IMGKit.new("Hello, world").to_blah }.should raise_error(IMGKit::UnknownFormatError)
+    end
+  end
+
+  context "#to_file" do
+    before do
+      @file_path = File.join(SPEC_ROOT,'fixtures','test.jpg')
+      File.delete(@file_path) if File.exist?(@file_path)
+    end
+
+    after do
+      File.delete(@file_path) if File.exist?(@file_path)
+    end
+
+    it "should create a file with the result of :to_img  as content" do
+      imgkit = IMGKit.new('html', :quality => 50)
+      imgkit.expects(:to_img).returns('CONTENT')
+      file = imgkit.to_file(@file_path)
+      file.should be_instance_of(File)
+      File.read(file.path).should == 'CONTENT'
+    end
+
+    IMGKit::KNOWN_FORMATS.each do |format|
+      it "should use the extension #{format} as the format" do
+        @file_path = File.join(SPEC_ROOT,'fixtures',"test.#{format}")
+        imgkit = IMGKit.new('html', :quality => 50)
+        file = imgkit.to_file(@file_path)
+        file.should be_instance_of(File)
+        File.open(file.path, "r:ASCII-8BIT") { |f| f.read.should be_a(format) }
+      end
+    end
+
+    it "should raise UnknownFormatError when format is unknown" do
+      kit = IMGKit.new("html")
+      lambda {
+        kit.to_file("file.bad_format")
+      }.should raise_error(IMGKit::UnknownFormatError)
+    end
+
+    it "should not create the file if format is unknown" do
+      kit = IMGKit.new("html")
+      kit.to_file("file.bad_format") rescue nil
+      File.exist?("file.bad_format").should be_false
+    end
+  end
+
+  context "security" do
+    before do
+      @test_path = File.join(SPEC_ROOT,'fixtures','security-oops')
+      File.delete(@test_path) if File.exist?(@test_path)
+    end
+
+    after do
+      File.delete(@test_path) if File.exist?(@test_path)
+    end
+
+    it "should not allow shell injection in options" do
+      imgkit = IMGKit.new('html', :password => "blah\"; touch #{@test_path} #")
+      lambda { imgkit.to_img }.should raise_error(IMGKit::CommandFailedError)
+    end
+  end
+end

data/spec/source_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe IMGKit::Source do
+
+  describe "#url?" do
+    it "should return true if passed a url like string" do
+      source = IMGKit::Source.new('http://google.com')
+      source.should be_url
+    end
+
+    it "should return false if passed a file" do
+      source = IMGKit::Source.new(File.new(__FILE__))
+      source.should_not be_url
+    end
+
+    it "should return false if passed HTML" do
+      source = IMGKit::Source.new('<blink>Oh Hai!</blink>')
+      source.should_not be_url
+    end
+
+    it "should return false if passed HTML with a line starting with 'http'" do
+      source = IMGKit::Source.new("<blink>Oh Hai!</blink>\nhttp://google.com")
+      source.should_not be_url
+    end
+  end
+
+  describe "#file?" do
+    it "should return true if passed a file" do
+      source = IMGKit::Source.new(File.new(__FILE__))
+      source.should be_file
+    end
+
+    it "should return true if passed a temporary file" do
+      source = IMGKit::Source.new(Tempfile.new 'temp_file')
+      source.should be_file
+    end
+
+    it "should return false if passed a url like string" do
+      source = IMGKit::Source.new('http://google.com')
+      source.should_not be_file
+    end
+
+    it "should return false if passed HTML" do
+      source = IMGKit::Source.new('<blink>Oh Hai!</blink>')
+      source.should_not be_file
+    end
+  end
+
+  describe "#html?" do
+    it "should return true if passed HTML" do
+      source = IMGKit::Source.new('<blink>Oh Hai!</blink>')
+      source.should be_html
+    end
+
+    it "should return false if passed a file" do
+      source = IMGKit::Source.new(File.new(__FILE__))
+      source.should_not be_html
+    end
+
+    it "should return false if passed a url like string" do
+      source = IMGKit::Source.new('http://google.com')
+      source.should_not be_html
+    end
+  end
+
+  describe "#to_s" do
+    it "should return the HTML if passed HTML" do
+      source = IMGKit::Source.new('<blink>Oh Hai!</blink>')
+      source.to_s.should == '<blink>Oh Hai!</blink>'
+    end
+
+    it "should return a path if passed a file" do
+      source = IMGKit::Source.new(File.new(__FILE__))
+      source.to_s.should == __FILE__
+    end
+
+    it "should return the url if passed a url like string" do
+      source = IMGKit::Source.new('http://google.com')
+      source.to_s.should == 'http://google.com'
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+SPEC_ROOT = File.dirname(__FILE__)
+$LOAD_PATH.unshift(SPEC_ROOT)
+$LOAD_PATH.unshift(File.join(SPEC_ROOT, '..', 'lib'))
+require 'imgkit'
+require 'rspec'
+require 'rspec/autorun'
+require 'mocha'
+require 'rack'
+require 'tempfile'
+
+RSpec.configure do |config|
+  config.before do
+    IMGKit.any_instance.stubs(:wkhtmltoimage).returns(
+      File.join(SPEC_ROOT,'..','bin','wkhtmltoimage-proxy')
+    )
+  end
+end
+
+module MagicNumber
+  extend self
+  JPG  = "\xFF\xD8\xFF\xE0"
+  JPEG = JPG
+  PNG  = "\x89\x50\x4e\x47"
+  TIFF = "\x49\x49\x2a\x00"
+  TIF  = TIFF
+  GIF  = "\x47\x49\x46\x38"
+
+
+  if "".respond_to?(:force_encoding) 
+    constants.each { |c| const_get(c).force_encoding("ASCII-8BIT")  }
+  end
+
+  def read(string)
+    string[0,4]
+  end
+end
+
+RSpec::Matchers.define :be_a do |expected|
+  match do |actual|
+    @expected = MagicNumber.const_get(expected.to_s.upcase)
+    MagicNumber.read(actual) == @expected
+  end
+
+  failure_message_for_should do |actual|
+    actual = MagicNumber.read(actual)
+    "expctected #{actual.inspect},#{actual.encoding} to equal #{@expected.inspect},#{@expected.encoding}"
+  end
+end

data/spec/warning_binary

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+for i in {1..1000}; do
+   echo "Some kind of a long error message so that the operating system buffer gets filled" > /dev/stderr
+done
+
+echo "result"

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: img-kit
+version: !ruby/object:Gem::Version
+  version: 1.3.9.1
+platform: ruby
+authors:
+- csquared
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-20 00:00:00.000000000 Z
+dependencies: []
+description: Uses wkhtmltoimage to create Images using HTML
+email: christopher.continanza@gmail.com
+executables:
+- imgkit
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- POST_INSTALL
+- README.md
+- Rakefile
+- bin/imgkit
+- imgkit.gemspec
+- lib/imgkit.rb
+- lib/imgkit/configuration.rb
+- lib/imgkit/imgkit.rb
+- lib/imgkit/source.rb
+- lib/imgkit/version.rb
+- spec/error_binary
+- spec/fixtures/example.css
+- spec/fixtures/example.html
+- spec/imgkit_spec.rb
+- spec/source_spec.rb
+- spec/spec_helper.rb
+- spec/warning_binary
+homepage: http://github.com/topspin/imgkit
+licenses: []
+metadata: {}
+post_install_message: |
+  ******************************************************************
+
+  Now install wkhtmltoimage binaries:
+  Global: sudo `which imgkit` --install-wkhtmltoimage
+          rvmsudo imgkit --install-wkhtmltoimage
+  (installs to default /usr/local/bin/wkhtmltoimage)
+
+  inside RVM folder: export TO=`which imgkit | sed 's:/imgkit:/wkhtmltoimage:'` && imgkit --install-wkhtmltoimage
+  (you'll have to configure the location of the binary if you do this!)
+
+  (run imgkit --help to see more options)
+  ******************************************************************
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.0
+signing_key: 
+specification_version: 4
+summary: HTML+CSS -> JPG
+test_files:
+- spec/error_binary
+- spec/fixtures/example.css
+- spec/fixtures/example.html
+- spec/imgkit_spec.rb
+- spec/source_spec.rb
+- spec/spec_helper.rb
+- spec/warning_binary
+has_rdoc: