webshooter 0.0.1a

data/.gitignore

@@ -0,0 +1 @@
+*.png

data/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gem "webshooter", :path => "."

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    webshooter (0.0.1a)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  webshooter!

data/README.txt

@@ -0,0 +1,32 @@
+This library uses the Webkit Ruby Cocoa library to take headless webshots
+
+# Usage 
+
+## From within ruby
+require 'webshooter'
+Webshooter.capture('http://www.jedi.be','jedi.png','1024x768')
+
+## As a commandline tool
+webshooter 'http://www.jedi.be' 'jedi.png' '1024x768'
+
+# Limitations
+- does not handle redirects currently
+- create more configurable options
+- cleanup code
+- only support png
+
+# Inspiration
+
+This library is a compilation of various parts I found on the web
+The research was done a few years ago, so unfortunatly I don't have all the references anymore
+
+- Darkroom -  Copyright (c) 2007 Justin Palmer.
+  - https://gist.github.com/34824 
+  - https://gist.github.com/86435
+
+- Thanks to the heavy lifting done by others:
+ -  https://gist.github.com/244948
+ - http://pastie.caboo.se/69235
+ - http://pastie.caboo.se/68511
+ - https://gist.github.com/248077 Webview to PDF
+ - http://www.bencurtis.com/wp-content/uploads/2008/05/snapper.rb

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'bundler'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+

data/bin/webshooter.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+
+require 'webshotr'
+
+module Webshotr
+	class CLI
+		#Ruby CLI tool - http://rubylearning.com/blog/2011/01/03/how-do-i-make-a-command-line-tool-in-ruby/
+		def self.execute(args)
+			url=args[0]
+			filename=args[1]
+			size=args[2]
+			webshotr=Webshotr.capture(url, filename, size )
+		end
+	end
+end
+
+Webshotr::CLI.execute(ARGV)

data/lib/webshooter/newnsurlrequest.rb

@@ -0,0 +1,9 @@
+module Webshooter
+	# We want to allow any https certificate
+	# OSX::NSURLRequest.setAllowsAnyHTTPSCertificate(true,myURI.host) has method missing
+	# Therefore we create a wrapper object
+	# NewRequest.setAllowsAnyHTTPSCertificate_forHost(true,OSX::NSURL.URLWithString(uri))
+
+	class NewNSURLRequest < OSX::NSURLRequest
+	end
+end

data/lib/webshooter/version.rb

@@ -0,0 +1,3 @@
+module Webshooter
+	VERSION = "0.0.1a"
+end

data/lib/webshooter/webshotprocessor.rb

@@ -0,0 +1,224 @@
+require 'osx/cocoa'
+require 'logger'
+require 'uri'
+
+require 'webshooter/newnsurlrequest'
+OSX.require_framework 'WebKit'
+
+#Respond to URL not found....
+#http://stackoverflow.com/questions/697108/testing-use-of-nsurlconnection-with-http-response-error-statuses
+#http://www.gigliwood.com/weblog/Cocoa/Q__When_is_an_conne.html
+#http://stackoverflow.com/questions/2236407/how-to-detect-and-handle-http-error-codes-in-uiwebview
+
+
+module Webshooter
+
+class WebShotProcessor 
+
+    def initialize
+      @logger = Logger.new(STDOUT)
+
+      # get NSApplication code ready for action
+      OSX.NSApplicationLoad
+
+      #	Make an offscreen window
+      # The frame is in screen coordinates, but it's irrelevant since we'll never display it
+      # We want a buffered backing store, simply so we can read it later
+      #	We don't want to defer, or it won't draw until it gets on the screen
+      rect = OSX::NSRect.new(-16000,-16000,100,100)
+      @window = OSX::NSWindow.alloc.initWithContentRect_styleMask_backing_defer(
+      rect , OSX::NSBorderlessWindowMask, OSX::NSBackingStoreBuffered, false
+      )
+
+      # Make a web @webView - the frame here is in window coordinates
+      @webView = OSX::WebView.alloc.initWithFrame(rect)      
+      
+      # Use the screen stylesheet, rather than the print one.
+      @webView.setMediaStyle('screen')
+      # Make sure we don't save any of the prefs that we change.
+      @webView.preferences.setAutosaves(false)
+      # Set some useful options.
+      @webView.preferences.setShouldPrintBackgrounds(true)
+      @webView.preferences.setJavaScriptCanOpenWindowsAutomatically(false)
+      @webView.preferences.setAllowsAnimatedImages(false)
+      # Make sure we don't get a scroll bar.
+      @webView.mainFrame.frameView.setAllowsScrolling(false)          
+
+      # This @delegate will get a message when the load completes
+      @delegate = SimpleLoadDelegate.alloc.init
+      @delegate.webshooter = self
+      @webView.setFrameLoadDelegate(@delegate)
+
+      # Replace the window's content @webView with the web @webView
+      @window.setContentView(@webView)
+      @webView.release
+      puts "its not in the release"
+    end
+
+    def capture(uri, path, dimensions = "1024x768" )
+      
+      snapshot_dimension=dimensions.split('x')
+      # Tell the frame to load the URL we want
+      @webView.window.setContentSize(snapshot_dimension) 
+      @webView.setFrameSize(snapshot_dimension)
+      
+      myURI = URI.parse(uri)
+       
+      #Allow all https certificates
+      NewNSURLRequest.setAllowsAnyHTTPSCertificate_forHost(true,myURI.host)
+      
+      #puts "Getting ready for the loadRequest"+uri
+      @webView.mainFrame.loadRequest(NewNSURLRequest.requestWithURL(OSX::NSURL.URLWithString(uri)))
+
+      #
+      # Run the main event loop until the frame loads
+      @timeout=false
+      result=OSX.CFRunLoopRunInMode(OSX::KCFRunLoopDefaultMode, 20, false)
+      if (result == OSX::KCFRunLoopRunTimedOut)
+        @timeout=true
+      end
+
+      #This is what we need but the upon_ also changes
+      #OSX.CFRunLoopRun
+      #puts "first loop enters here"
+      
+      puts "its not in the after upon success"
+         
+      upon_success do |view| # Capture the content of the view as an image
+
+        view.window.orderFront(nil)
+        view.window.display
+  
+        #puts "-------------------------------------------------"
+        #puts "We got success"
+        @docview=view.mainFrame.frameView.documentView
+
+        #We need the contents of the first frame
+        #pp view.bounds
+        #pp @docview.bounds
+
+        if @docview.bounds.size.height == 0.0
+          #pp "trying alternative"
+          #pp @docview
+          @docview= view.mainFrame.frameView.documentView
+        else
+          view.window.setContentSize(@docview.bounds.size)
+          view.setFrame(@docview.bounds)
+          if view.bounds.size.height > 300000
+            #view.bounds.size.height=300000
+            #puts "Adjusted maximum size to 300000"
+          end
+        end
+
+
+        # Write the bitmap to a file as a PNG
+        #
+        #view.bounds=initialsize
+        #view.window.setContentSize(view.bounds.size)
+        
+        view.setNeedsDisplay(true)
+        view.displayIfNeeded
+        if view.bounds.size.height < 300000
+          view.lockFocus
+          bitmap = OSX::NSBitmapImageRep.alloc.initWithFocusedViewRect(view.bounds)
+          bitmap.representationUsingType_properties(OSX::NSPNGFileType, nil).writeToFile_atomically(path, true)
+          bitmap.release
+          view.unlockFocus
+
+        else
+          puts "Something went wrong, the size became to big"
+        end
+
+      end
+
+      upon_failure do |error, logger|
+        logger.warn("Unable to load URI: #{uri} (#{error})")
+      end
+      
+      
+    end
+
+    def release
+      #@window.release
+      @delegate.release
+    end
+
+    attr_accessor :load_success, :load_error
+
+    private
+
+    def upon_success(&block)
+      block.call(@webView) if @load_success
+    end
+
+    def upon_failure(&block)
+      if (@timeout)
+        block.call("Timeout error", @logger) unless @load_success
+      else
+        block.call(@load_error.localizedDescription, @logger) unless @load_success
+      end
+    end
+
+
+    class SimpleLoadDelegate < OSX::NSObject
+
+      attr_accessor :webshooter
+
+      def stopLoop
+        mainLoop=OSX.CFRunLoopGetMain
+        currentLoop=OSX.CFRunLoopGetCurrent
+        OSX.CFRunLoopStop(mainLoop)
+        OSX.CFRunLoopStop(currentLoop)
+      end
+
+      def webView_didFinishLoadForFrame(sender, frame)
+        #This did the trick, we have to wait for the right frame to load, not other frames
+        if (frame == sender.mainFrame)
+          then
+          #puts "Finish Load For Frame"
+          @webshooter.load_success = true; 
+
+          stopLoop
+        else
+          #puts "WARN: the mainframe is not the frame"
+          return
+        end
+      end
+
+      def webView_didFailLoadWithError_forFrame(webview, load_error, frame)
+
+        #This is trick # 2
+        #We have to catch this stupid error
+        if (load_error.code == OSX::NSURLErrorCancelled) 
+          then
+          #pp "WARN: did Fail with Error For Frame"
+          #pp "WARN: we don't give up"
+          return
+        else
+          #puts load_error.localizedDescription
+        end
+
+        @webshooter.load_success = false; @webshooter.load_error = load_error; 
+
+        stopLoop
+      end
+
+      def webView_didFailProvisionalLoadWithError_forFrame(webview, load_error, frame)
+        if (load_error.code == OSX::NSURLErrorCancelled) 
+          then
+          #pp "WARN: did Fail PROVISIONAL LOAD WITH ERROR For Frame"
+          #pp "WARN: we don't give up"
+          return
+        else
+          #puts load_error.localizedDescription
+        end
+        @webshooter.load_success = false; @webshooter.load_error = load_error; 
+
+        stopLoop
+      end
+
+    end
+
+  end
+
+end

data/lib/webshooter.rb

@@ -0,0 +1,13 @@
+require 'webshooter/webshotprocessor'
+
+# We might handle redirection in the future
+# http://shadow-file.blogspot.com/2009/03/handling-http-redirection-in-ruby.html
+
+module Webshooter
+	class Webshooter
+	  def self.capture(uri, path, dimensions = "1024x768" )
+	    webProcessor=WebShotProcessor.new
+	    webProcessor.capture(uri,path,dimensions)
+	  end
+	end
+end

data/trials/darkroom.orig.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+#
+# DarkRoom
+# Takes fullsize screenshots of a web page.
+# Copyright (c) 2007 Justin Palmer.
+#
+# Released under an MIT LICENSE
+#
+# Usage
+# ====
+# ruby ./darkroom.rb http://activereload.net
+# ruby ./darkroom.rb --output=google.png http://google.com
+#
+require 'optparse'
+require 'osx/cocoa'
+OSX.require_framework 'Webkit'
+
+module ActiveReload
+  module DarkRoom
+    USER_AGENT = "DarkRoom/0.1"
+    class Photographer
+      def initialize
+        options = {}
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: #$0 [options] URL"
+      
+          opts.on('-w', '--width=[WIDTH]', Integer, 'Force width of the screenshot') do |v|
+            options[:width] = v
+          end
+      
+          opts.on('-h', '--height=[HEIGHT]', Integer, 'Force height of screenshot') do |v|
+            options[:height] = v
+          end
+          
+          opts.on('-o', '--output=[FILENAME]', String, 'Specify filename for saving') do |v|
+            options[:output] = v
+          end
+      
+          opts.on_tail('-h', '--help', 'Display this message and exit') do
+            puts opts
+            exit
+          end
+        end.parse!
+        options[:width]  ||= 1024
+        options[:height] ||= 0
+        options[:website] = ARGV.first || 'http://google.com'
+        Camera.shoot(options)
+        Camera.shoot(options)
+      end
+    end
+
+    class Camera
+      def self.shoot(options)
+        app = OSX::NSApplication.sharedApplication
+        delegate = Processor.alloc.init
+        delegate.options = options
+        app.setDelegate(delegate)        
+        app.run
+      end
+    end
+
+    class Processor < OSX::NSObject
+      include OSX
+      attr_accessor :options, :web_view
+  
+      def initialize
+        rect = [-16000.0, -16000.0, 100, 100]
+        win = NSWindow.alloc.initWithContentRect_styleMask_backing_defer(rect, NSBorderlessWindowMask, 2, 0)
+    
+        @web_view = WebView.alloc.initWithFrame(rect)
+        @web_view.mainFrame.frameView.setAllowsScrolling(false)
+        @web_view.setApplicationNameForUserAgent(USER_AGENT)
+    
+        NSNotificationCenter.defaultCenter.objc_send(:addObserver, self,
+          :selector, :webview_progress_finished, 
+          :name, WebViewProgressFinishedNotification,
+          :object, @web_view)
+
+        win.setContentView(@web_view) 
+      end
+      
+      def webview_progress_finished(sender)
+        viewport = web_view.mainFrame.frameView.documentView
+        viewport.window.orderFront(nil)
+        viewport.window.display
+        viewport.window.setContentSize([@options[:width], (@options[:height] > 0 ? @options[:height] : viewport.bounds.height)])
+        viewport.setFrame(viewport.bounds)
+        sleep(@options[:delay]) if @options[:delay]
+        capture_and_save(viewport)
+      end
+      
+      def applicationDidFinishLaunching(notification)
+        @options[:output] ||= "#{Time.now.strftime('%m-%d-%y-%H%I%S')}.png"
+        @web_view.window.setContentSize([@options[:width], @options[:height]])
+        @web_view.setFrameSize([@options[:width], @options[:height]])
+        @web_view.mainFrame.loadRequest(NSURLRequest.requestWithURL(NSURL.URLWithString(@options[:website])))
+      end
+  
+      def capture_and_save(view)
+        print "we never get here"
+        view.lockFocus
+          bitmap = NSBitmapImageRep.alloc.initWithFocusedViewRect(view.bounds)
+        view.unlockFocus
+    
+        bitmap.representationUsingType_properties(NSPNGFileType, nil).writeToFile_atomically(@options[:output], true)
+        #NSApplication.sharedApplication.terminate(nil)
+      end
+    end
+  end
+end
+ActiveReload::DarkRoom::Photographer.new
+ActiveReload::DarkRoom::Photographer.new

data/trials/darkroom.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+#
+# DarkRoom
+# Takes fullsize screenshots of a web page.
+# Copyright (c) 2007 Justin Palmer.
+#
+# Released under an MIT LICENSE
+#
+# Usage
+# ====
+# ruby ./darkroom.rb http://activereload.net
+# ruby ./darkroom.rb --output=google.png http://google.com
+#
+require 'optparse'
+require 'osx/cocoa'
+OSX.require_framework 'Webkit'
+
+module ActiveReload
+  module DarkRoom
+    USER_AGENT = "DarkRoom/0.1"
+
+    class Camera
+      def self.shoot(options)
+        app = OSX::NSApplication.sharedApplication
+        delegate = Processor.alloc.init
+        delegate.options = options
+        app.setDelegate(delegate)        
+        app.run
+      end
+    end
+
+    class Processor < OSX::NSObject
+      include OSX
+      attr_accessor :options, :web_view
+  
+      def initialize
+        rect = [-16000.0, -16000.0, 100, 100]
+        win = NSWindow.alloc.initWithContentRect_styleMask_backing_defer(rect, NSBorderlessWindowMask, 2, 0)
+    
+        @web_view = WebView.alloc.initWithFrame(rect)
+        @web_view.mainFrame.frameView.setAllowsScrolling(false)
+        @web_view.setApplicationNameForUserAgent(USER_AGENT)
+    
+        NSNotificationCenter.defaultCenter.objc_send(:addObserver, self,
+          :selector, :webview_progress_finished, 
+          :name, WebViewProgressFinishedNotification,
+          :object, @web_view)
+
+        win.setContentView(@web_view) 
+      end
+      
+      def webview_progress_finished(sender)
+        viewport = web_view.mainFrame.frameView.documentView
+        viewport.window.orderFront(nil)
+        viewport.window.display
+        viewport.window.setContentSize([@options[:width], (@options[:height] > 0 ? @options[:height] : viewport.bounds.height)])
+        viewport.setFrame(viewport.bounds)
+        sleep(@options[:delay]) if @options[:delay]
+        capture_and_save(viewport)
+      end
+      
+      def applicationDidFinishLaunching(notification)
+        @options[:output] ||= "#{Time.now.strftime('%m-%d-%y-%H%I%S')}.png"
+        @web_view.window.setContentSize([@options[:width], @options[:height]])
+        @web_view.setFrameSize([@options[:width], @options[:height]])
+        @web_view.mainFrame.loadRequest(NSURLRequest.requestWithURL(NSURL.URLWithString(@options[:website])))
+      end
+  
+      def capture_and_save(view)
+        print "we never get here"
+        view.lockFocus
+          bitmap = NSBitmapImageRep.alloc.initWithFocusedViewRect(view.bounds)
+        view.unlockFocus
+    
+        bitmap.representationUsingType_properties(NSPNGFileType, nil).writeToFile_atomically(@options[:output], true)
+        #NSApplication.sharedApplication.terminate(nil)
+      end
+    end
+  end
+end
+#ActiveReload::DarkRoom::Photographer.new

data/trials/snapper.orig.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+# Thanks to the heavy lifting done by others:
+# http://pastie.caboo.se/69235
+# http://pastie.caboo.se/68511
+
+require 'osx/cocoa'
+OSX.require_framework 'WebKit'
+
+class Snapper < OSX::NSObject
+
+  def init
+    # This sets up some context that we need for creating windows.
+    OSX::NSApplication.sharedApplication
+    
+    # Create an offscreen window into which we can stick our WebView.
+    @window = OSX::NSWindow.alloc.initWithContentRect_styleMask_backing_defer(
+      [0, 0, 800, 600], OSX::NSBorderlessWindowMask, OSX::NSBackingStoreBuffered, false
+    )
+
+    # Create a WebView and stick it in our offscreen window.
+    @webView = OSX::WebView.alloc.initWithFrame([0, 0, 800, 600])
+    @window.setContentView(@webView)
+    
+    # Use the screen stylesheet, rather than the print one.
+    @webView.setMediaStyle('screen')
+    # Make sure we don't save any of the prefs that we change.
+    @webView.preferences.setAutosaves(false)
+    # Set some useful options.
+    @webView.preferences.setShouldPrintBackgrounds(true)
+    @webView.preferences.setJavaScriptCanOpenWindowsAutomatically(false)
+    @webView.preferences.setAllowsAnimatedImages(false)
+    # Make sure we don't get a scroll bar.
+    @webView.mainFrame.frameView.setAllowsScrolling(false)
+    
+    self
+  end
+  
+  def fetch(url)
+    # This sets up the webView_*  methods to be called when loading finishes.
+    @webView.setFrameLoadDelegate(self)
+    # Tell the webView what URL to load.
+    @webView.setValue_forKey(url, 'mainFrameURL')
+    # Pass control to Cocoa for a bit.
+    OSX.CFRunLoopRun
+    @succeeded
+  end
+  
+  attr_reader :error
+  
+  def webView_didFinishLoadForFrame(view, frame)
+    @succeeded = true
+    
+    # Resize the view to fit the page.
+    @docView = @webView.mainFrame.frameView.documentView
+    @docView.window.setContentSize(@docView.bounds.size)
+    @docView.setFrame(@docView.bounds)
+    
+    # Return control to the fetch method.
+    OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+  end
+  
+  def webView_didFailLoadWithError_forFrame(webview, error, frame)
+    @error = error
+    @succeeed = false
+    # Return control to the fetch method.
+    OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+  end
+  
+  def webView_didFailProvisionalLoadWithError_forFrame(webview, error, frame)
+    @error = error
+    @succeeed = false
+    # Return control to the fetch method.
+    OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+  end
+  
+  def save(filename, options = {})
+    @docView.setNeedsDisplay(true)
+    @docView.displayIfNeeded
+    @docView.lockFocus
+    bitmap = OSX::NSBitmapImageRep.alloc.initWithFocusedViewRect(@docView.bounds)
+    @docView.unlockFocus
+
+    # Write the bitmap to a file as a PNG
+    bitmap.representationUsingType_properties(OSX::NSPNGFileType, nil).writeToFile_atomically(filename, true)
+    bitmap.release
+  end
+  
+end
+

data/trials/snapper.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+# Thanks to the heavy lifting done by others:
+# http://pastie.caboo.se/69235
+# http://pastie.caboo.se/68511
+
+require 'osx/cocoa'
+OSX.require_framework 'WebKit'
+
+class Snapper < OSX::NSObject
+
+  def init
+    # This sets up some context that we need for creating windows.
+    OSX::NSApplication.sharedApplication
+    
+    # Create an offscreen window into which we can stick our WebView.
+    #@window = OSX::NSWindow.alloc.initWithContentRect_styleMask_backing_defer(
+    #  [0, 0, 800, 600], OSX::NSBorderlessWindowMask, OSX::NSBackingStoreBuffered, false
+    #)
+    rect = [-16000.0, -16000.0, 100, 100]
+    @window = OSX::NSWindow.alloc.initWithContentRect_styleMask_backing_defer(rect, OSX::NSBorderlessWindowMask, OSX::NSBackingStoreBuffered, false )
+
+
+
+    # Create a WebView and stick it in our offscreen window.
+    #@webView = OSX::WebView.alloc.initWithFrame([0, 0, 800, 600])
+    @webView = OSX::WebView.alloc.initWithFrame(rect)
+    @window.setContentView(@webView)
+    
+    # Use the screen stylesheet, rather than the print one.
+    @webView.setMediaStyle('screen')
+    # Make sure we don't save any of the prefs that we change.
+    @webView.preferences.setAutosaves(false)
+    # Set some useful options.
+    @webView.preferences.setShouldPrintBackgrounds(true)
+    @webView.preferences.setJavaScriptCanOpenWindowsAutomatically(false)
+    @webView.preferences.setAllowsAnimatedImages(false)
+    # Make sure we don't get a scroll bar.
+    @webView.mainFrame.frameView.setAllowsScrolling(false)
+    
+    self
+  end
+  
+  def fetch(url)
+    # This sets up the webView_*  methods to be called when loading finishes.
+    @webView.setFrameLoadDelegate(self)
+    # Tell the webView what URL to load.
+    @webView.setValue_forKey(url, 'mainFrameURL')
+    # Pass control to Cocoa for a bit.
+    OSX.CFRunLoopRun
+    @succeeded
+  end
+  
+  attr_reader :error
+  
+  def webView_didFinishLoadForFrame(view, frame)
+    @succeeded = true
+    
+    # Resize the view to fit the page.
+    @docView = @webView.mainFrame.frameView.documentView
+    @docView.window.orderFront(nil)
+    @docView.display
+    @docView.window.setContentSize(@docView.bounds.size)
+    @docView.setFrame(@docView.bounds)
+    sleep(4) 
+    # Return control to the fetch method.
+    OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+  end
+  
+  def webView_didFailLoadWithError_forFrame(webview, error, frame)
+    @error = error
+    @succeeed = false
+    # Return control to the fetch method.
+    OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+  end
+  
+  def webView_didFailProvisionalLoadWithError_forFrame(webview, error, frame)
+    @error = error
+    @succeeed = false
+    # Return control to the fetch method.
+    OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+  end
+  
+  def save(filename, options = {})
+    @docView.setNeedsDisplay(true)
+    @docView.displayIfNeeded
+    @docView.lockFocus
+    bitmap = OSX::NSBitmapImageRep.alloc.initWithFocusedViewRect(@docView.bounds)
+    @docView.unlockFocus
+
+    # Write the bitmap to a file as a PNG
+    bitmap.representationUsingType_properties(OSX::NSPNGFileType, nil).writeToFile_atomically(filename, true)
+    bitmap.release
+  end
+  
+end
+

data/trials/webkit-shooter.orig.rb

@@ -0,0 +1,101 @@
+# crafterm@redartisan.com, with major help from vastheman :)
+
+require 'osx/cocoa'
+require 'logger'
+
+OSX.require_framework 'WebKit'
+
+class Shooter
+
+  def initialize
+    @logger = Logger.new(STDOUT)
+    
+    @pool = OSX::NSAutoreleasePool.alloc.init
+
+    # get NSApplication code ready for action
+    OSX.NSApplicationLoad
+
+    #	Make an offscreen window
+    # The frame is in screen coordinates, but it's irrelevant since we'll never display it
+    # We want a buffered backing store, simply so we can read it later
+    #	We don't want to defer, or it won't draw until it gets on the screen
+    @window = OSX::NSWindow.alloc.initWithContentRect_styleMask_backing_defer(
+                OSX::NSRect.new(0, 0, 1024, 768), OSX::NSBorderlessWindowMask, OSX::NSBackingStoreBuffered, false
+             )
+
+    # Make a web @view - the frame here is in window coordinates
+    @view = OSX::WebView.alloc.initWithFrame(OSX::NSRect.new(0, 0, 1024, 768))
+    @view.mainFrame.frameView.setAllowsScrolling(false)
+
+    # This @delegate will get a message when the load completes
+    @delegate = SimpleLoadDelegate.alloc.init
+    @delegate.shooter = self
+    @view.setFrameLoadDelegate(@delegate)
+
+    # Replace the window's content @view with the web @view
+    @window.setContentView(@view)
+    @view.release
+  end
+  
+  def capture(uri, path)
+    # Tell the frame to load the URL we want
+    @view.mainFrame.loadRequest(OSX::NSURLRequest.requestWithURL(OSX::NSURL.URLWithString(uri)))
+    
+    # Run the main event loop until the frame loads
+    OSX.CFRunLoopRun
+    
+    upon_success do |view| # Capture the content of the view as an image
+      view.setNeedsDisplay(true)
+      view.displayIfNeeded
+      view.lockFocus
+      bitmap = OSX::NSBitmapImageRep.alloc.initWithFocusedViewRect(view.bounds)
+      view.unlockFocus
+      
+      # Write the bitmap to a file as a PNG
+      bitmap.representationUsingType_properties(OSX::NSPNGFileType, nil).writeToFile_atomically(path, true)
+      bitmap.release
+    end
+    
+    upon_failure do |error, logger|
+      logger.warn("Unable to load URI: #{uri} (#{error})")
+    end
+  end
+  
+  def release
+    @window.release
+    @delegate.release
+    @pool.release
+  end
+  
+  attr_accessor :load_success, :load_error
+  
+  private
+  
+  def upon_success(&block)
+    block.call(@view) if @load_success
+  end
+  
+  def upon_failure(&block)
+    block.call(@load_error.localizedDescription, @logger) unless @load_success
+  end
+
+  class SimpleLoadDelegate < OSX::NSObject
+
+    attr_accessor :shooter
+
+    def webView_didFinishLoadForFrame(sender, frame)
+      @shooter.load_success = true; OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+    end
+    
+    def webView_didFailLoadWithError_forFrame(webview, load_error, frame)
+      @shooter.load_success = false; @shooter.load_error = load_error; OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+    end
+
+    def webView_didFailProvisionalLoadWithError_forFrame(webview, load_error, frame)
+      @shooter.load_success = false; @shooter.load_error = load_error; OSX.CFRunLoopStop(OSX.CFRunLoopGetCurrent)
+    end
+
+  end
+  
+end
+

data/webshooter.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/webshooter/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "webshooter"
+  s.version     = Webshooter::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Patrick Debois"]
+  s.email       = ["patrick.debois@jedi.be"]
+  s.homepage    = "http://github.com/jedi4ever/webshooter/"
+  s.summary     = %q{Create webshot using webkit on MacOSX}
+  s.description = %q{This library allows you to create webshots using webkit on MacOSX. A webshot is a screenshot taking inside the browser. The advantage of this library is that it is headless and gives you the real view not a parsed view}
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "webshooter"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: webshooter
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 1a
+  version: 0.0.1a
+platform: ruby
+authors: 
+- Patrick Debois
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-19 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id001
+  name: bundler
+  prerelease: false
+  type: :development
+description: This library allows you to create webshots using webkit on MacOSX. A webshot is a screenshot taking inside the browser. The advantage of this library is that it is headless and gives you the real view not a parsed view
+email: 
+- patrick.debois@jedi.be
+executables: 
+- webshooter.rb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.txt
+- Rakefile
+- bin/webshooter.rb
+- lib/webshooter.rb
+- lib/webshooter/newnsurlrequest.rb
+- lib/webshooter/version.rb
+- lib/webshooter/webshotprocessor.rb
+- trials/darkroom.orig.rb
+- trials/darkroom.rb
+- trials/snapper.orig.rb
+- trials/snapper.rb
+- trials/webkit-shooter.orig.rb
+- webshooter.gemspec
+has_rdoc: true
+homepage: http://github.com/jedi4ever/webshooter/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: webshooter
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Create webshot using webkit on MacOSX
+test_files: []
+