kelredd-pruview 0.1.1

data/README.rdoc

@@ -0,0 +1,62 @@
+= Pruview
+
+== Description
+
+A gem to ease generating image previews (thumbnails) of various files
+
+== Installation
+
+    # install image magick with whatever build dependencies you need for image handling, etc...)
+    # if you want to preview movie files
+    # => install ffmpeg with whatever build dependencies you need for video/audio handling, etc...)
+    # if you want to preview postscript files (PDFs, Adobe Illustrator, etc...)
+    # => install any postscript handling libs or dependencies for image magick
+    
+    sudo gem install kelredd-pruview --source http://gems.github.com
+
+== Dependencies
+
+    * image magick + any special file type handling dependencies
+    * ffmpeg + h264 encoder + any special file type handling dependencies (for video previewing)
+      # something like 'sudo port install ffmpeg +gpl +lame +x264 +xvid' on Mac OSX Leopard
+    * gawk
+    * Rubygems: mini_magick
+
+== Usage
+
+    require 'pruview'
+
+    # Preview a document (using image magick)
+    document = Pruview::Document.new(<document_file_path>, <pruview_output_path>)
+    doc_image_thumb_path = document.to_jpg(<thumb_file_name>, <thumb_pixel_width>, <thumb_pixel_height)
+
+    # Preview a video (ffmpeg to get an image from movie, then image magick to resize that image)
+    video_image_path = Pruview::VideoImage.to_jpg(<video_file_path>, <pruview_output_path>, <video_image_file_name>)
+    document = Pruview::Document.new(video_image_path, <pruview_output_path>)
+    video_image_thumb_path = document.to_jpg(<thumb_file_name>, <thumb_pixel_width>, <thumb_pixel_height)
+    
+
+== License
+
+Copyright (c) 2007-2009 Kelly Redding
+
+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/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/pruview/version'
+
+task :default => :test
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'pruview'
+  s.version          = Pruview::Version.to_s
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "A gem to ease generating image previews (thumbnails) of various files"
+  s.author           = 'Kelly Redding'
+  s.email            = 'kelly@kelredd.com'
+  s.homepage         = ''
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{features,lib,test}/**/*")
+  # s.executables    = ['pruview']
+  
+  s.add_dependency('mini_magick')
+  s.add_dependency('flvtool2')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+desc 'Generate the gemspec to serve this Gem from Github'
+task :github do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/features/document.feature

@@ -0,0 +1,21 @@
+Feature: Document
+  In order have file thumbnails programmatically
+  As a user
+  I want create document file thumbnails
+  
+  Scenario: Basic Image thumbnail
+    Given I have a basic image document
+    When I create a jpg version
+    Then I should have a jpg file
+
+  Scenario: Invalid source image
+    Given I have an invalid image document
+    Then Pruview should complain about an invalid source file
+
+  Scenario: Invalid output path
+    Given I have an invalid output path for documents
+    Then Pruview should complain about an invalid output path
+
+  Scenario: Invalid source format
+    Given I have an invalid format document
+    Then Pruview should complain about an invalid source file format

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,32 @@
+When /^I create a[n]* (.+) version$/ do |format|
+  @output = @file.send("to_#{format}", 'file', 50, 50)
+end
+
+Then /^I should have a[n]* (.+) file$/ do |format|
+  assert File.exists?(@output)
+  assert File.extname(@output), format
+end
+
+Then /^Pruview should complain about an invalid source file$/ do
+  assert @complaint
+  assert_kind_of Pruview::Exceptions::InvalidError, @complaint
+  assert_match /^Invalid source file/, @complaint.message
+end
+
+Then /^Pruview should complain about an invalid output path$/ do
+  assert @complaint
+  assert_kind_of Pruview::Exceptions::InvalidError, @complaint
+  assert_match /^Invalid target directory/, @complaint.message
+end
+
+Then /^Pruview should complain about an invalid source file format$/ do
+  assert @complaint
+  assert_kind_of Pruview::Exceptions::InvalidError, @complaint
+  assert_match /not supported - file extension: .poop/, @complaint.message
+end
+
+Then /^Pruview should complain about an error$/ do
+  assert @complaint
+  assert_kind_of Pruview::Exceptions::InvalidError, @complaint
+  assert_match /not supported - file extension: .poop/, @complaint.message
+end

data/features/step_definitions/document_steps.rb

@@ -0,0 +1,16 @@
+Given /^I have a[n]* (.+) document$/ do |file_type|
+  begin
+    @file = Pruview::Document.new(FILES[file_type], OUTPUT_PATH)
+  rescue Exception => err
+    @complaint = err
+  end
+end
+
+Given /^I have an invalid output path for documents$/ do
+  begin
+    @file = Pruview::Document.new(FILES['basic image'], INVALID_OUTPUT_PATH)
+  rescue Exception => err
+    @complaint = err
+  end
+end
+

data/features/step_definitions/support/env.rb

@@ -0,0 +1,20 @@
+require 'test/unit/assertions'
+World(Test::Unit::Assertions)
+
+require File.dirname(__FILE__) + '/../../../lib/pruview'
+
+FILES_PATH = "./test/files"
+OUTPUT_PATH = "./test_output"
+INVALID_OUTPUT_PATH = "./test_output/invalid"
+FILES = {
+  'basic image' => "./test/files/basic.jpg",
+  'invalid image' => "./test/files/invalid.jpg",
+  'error image' => "./test/files/error.jpg",
+  'basic video' => "./test/files/basic.mpg",
+  'invalid video' => "./test/files/invalid.mov",
+  'error video' => "./test/files/error.mov",
+  'invalid format' => "./test/files/invalid_format.poop"
+}
+
+FileUtils.mkdir_p File.expand_path(FILES_PATH) unless File.exists? File.expand_path(FILES_PATH)
+FileUtils.mkdir_p File.expand_path(OUTPUT_PATH) unless File.exists? File.expand_path(OUTPUT_PATH)

data/features/step_definitions/support/helpers.rb

@@ -0,0 +1,5 @@
+module PruviewFeature
+  module Helpers
+    
+  end
+end

data/features/step_definitions/video_image_steps.rb

@@ -0,0 +1,16 @@
+Given /^I have a[n]* (.+) video image (.+)$/ do |file_type, format|
+  begin
+    @output = Pruview::VideoImage.send("to_#{format}", FILES[file_type], OUTPUT_PATH, 'file')
+  rescue Exception => err
+    @complaint = err
+  end
+end
+
+Given /^I have an invalid output path for video images$/ do
+  begin
+    @output = Pruview::VideoImage.to_jpg(FILES['basic video'], INVALID_OUTPUT_PATH, 'file')
+  rescue Exception => err
+    @complaint = err
+  end
+end
+

data/features/step_definitions/video_steps.rb

@@ -0,0 +1,16 @@
+Given /^I have a[n]* (.+) file$/ do |file_type|
+  begin
+    @file = Pruview::Video.new(FILES[file_type], OUTPUT_PATH)
+  rescue Exception => err
+    @complaint = err
+  end
+end
+
+Given /^I have an invalid output path for videos$/ do
+  begin
+    @file = Pruview::Video.new(FILES['basic video'], INVALID_OUTPUT_PATH)
+  rescue Exception => err
+    @complaint = err
+  end
+end
+

data/features/video.feature

@@ -0,0 +1,26 @@
+Feature: Video
+  In order to use video in more universal ways
+  As a user
+  I want convert video to other formats for viewing
+  
+  Scenario: Basic video to FLV
+    Given I have a basic video file
+    When I create an flv version
+    Then I should have an flv file
+
+  Scenario: Basic video to MOV
+    Given I have a basic video file
+    When I create an mov version
+    Then I should have an mov file
+
+  Scenario: Invalid source video
+    Given I have an invalid video file
+    Then Pruview should complain about an invalid source file
+
+  Scenario: Invalid output path
+    Given I have an invalid output path for videos
+    Then Pruview should complain about an invalid output path
+
+  Scenario: Invalid source format
+    Given I have an invalid format file
+    Then Pruview should complain about an invalid source file format

data/features/video_image.feature

@@ -0,0 +1,20 @@
+Feature: Video Image
+  In order have video image thumbnails programmatically
+  As a user
+  I want create video image file thumbnails
+  
+  Scenario: Basic Image thumbnail
+    Given I have a basic video video image jpg
+    Then I should have a jpg file
+
+  Scenario: Invalid source image
+    Given I have an invalid video video image jpg
+    Then Pruview should complain about an invalid source file
+
+  Scenario: Invalid output path
+    Given I have an invalid output path for video images
+    Then Pruview should complain about an invalid output path
+
+  Scenario: Invalid source format
+    Given I have an invalid format video image jpg
+    Then Pruview should complain about an invalid source file format

data/lib/pruview.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'mini_magick'
+require 'yaml'
+
+require File.join(File.dirname(__FILE__), 'pruview', 'exceptions.rb')
+require File.join(File.dirname(__FILE__), 'pruview', 'document.rb')
+require File.join(File.dirname(__FILE__), 'pruview', 'video.rb')
+require File.join(File.dirname(__FILE__), 'pruview', 'video_image.rb')

data/lib/pruview/document.rb

@@ -0,0 +1,138 @@
+module Pruview
+
+  class Document
+    
+    def initialize(source, target_dir)
+      raise Pruview::Exceptions::InvalidError, "Invalid source file: #{source.to_s}" if !File.file?(source)
+      raise Pruview::Exceptions::InvalidError, "Invalid target directory: #{target_dir.to_s}" if !File.directory?(target_dir)
+      raise Pruview::Exceptions::InvalidError, "Document not supported - file extension: " + file_extension(source) if !format_supported?(source)
+      @source = source
+      @target_dir = target_dir
+      @image = process_image(get_image(source))
+      @tempfile = nil
+    end
+  
+    def to_jpg(name, width, height, crop = false)
+      scale_img = scale_image(width, height, crop)
+      scale_img.combine_options do |img|
+        img.format 'jpg'
+        img.quality '90'
+        img.interlace 'plane'
+      end
+      target = File.join(@target_dir, name.to_s + '.jpg')
+      scale_img.write(target)
+      return target
+    end
+    
+  protected
+  
+    def format_supported?(source)
+      file_ext = file_extension(source)
+      #return true if file_ext == PSD_EXT  # don't support photoshop for now
+      POSTSCRIPT_EXT.each { |extension| return true if file_ext == extension }
+      IMAGE_EXT.each { |extension| return true if file_ext == extension }
+      return false
+    end
+    
+    def format_postscript?(source)
+      file_ext = file_extension(source)
+      POSTSCRIPT_EXT.each { |extension| return true if file_ext == extension }
+      return false
+    end
+    
+    def file_extension(source_file)
+       File.extname(source_file).downcase.chomp  
+    end
+    
+    def get_image(source)
+      source = get_postscript_source(source) if format_postscript?(source)
+      begin
+        return MiniMagick::Image.from_file(source)
+      rescue Exception => err
+        raise "Error reading source image: #{err.message}"
+      end
+    end
+    
+    def get_postscript_source(source)
+      begin
+        @tempfile = MiniMagick::ImageTempFile.new("pruview.jpg")
+        @tempfile.binmode
+      ensure
+        @tempfile.close
+      end
+      run_system_command("convert -format jpg \"#{source}[0]\" \"#{@tempfile.path}\"", "Error processing postscript document")
+      return @tempfile.path
+    end
+    
+    def process_image(image)
+      image.format PROCESS_FORMAT
+      set_RGB_colorspace(image)
+      image.strip
+      return image
+    end
+    
+    def set_RGB_colorspace(image)
+      colorspace = run_system_command("identify -format \"%r\" #{image.path}", "Error reading document colorspace")
+      puts "Colorspace: #{colorspace}"
+      if colorspace =~ /CMYK/
+        image.combine_options do |img|
+          img.profile File.join(File.dirname(__FILE__), 'USWebCoatedSWOP.icc')
+          img.profile File.join(File.dirname(__FILE__), 'sRGB.icm')
+          img.colorspace 'sRGB'
+        end
+      end
+    end
+
+    def scale_image(width, height, crop = false)
+      begin
+        image = MiniMagick::Image.from_file(@image.path)
+        crop_image(image, crop)
+        image.resize "#{width}x#{height}" if crop || @image[:width].to_i > width || @image[:height] > height 
+        return image
+      rescue Exception => err
+        raise "Error scaling image: #{err.message}"
+      end
+    end
+    
+    def crop_image(image, ratio)
+      if ratio.kind_of?(Array) && ratio.length == 2
+        ratio_width, ratio_height = ratio
+        puts "image orig size: #{image[:width].to_i}x#{image[:height].to_i}"
+        puts "ratio_width: #{ratio_width}, ratio_height: #{ratio_height}"
+        if ratio_width > ratio_height || (ratio_width == ratio_height && image[:height].to_i > image[:width].to_i)
+          # calc ratio height from width
+          rheight = (image[:width].to_i*(ratio_height.to_f / ratio_width.to_f)).round
+          puts "rheight: #{rheight}"
+          # shave off height
+          shave_off = ((image[:height].to_i - rheight)/2).round
+          puts "shave off height: #{image[:height].to_i - rheight}"
+          image.shave("0x#{shave_off}")
+          puts "image crop size: #{image[:width].to_i}x#{image[:height].to_i}"
+        elsif ratio_height > ratio_width || (ratio_width == ratio_height && image[:width].to_i > image[:height].to_i)
+          # calc ratio width from height
+          rwidth = (image[:height].to_i*(ratio_width.to_f / ratio_height.to_f)).round
+          # shave off width
+          shave_off = ((image[:width].to_i - rwidth).to_f / 2.to_f).round
+          image.shave("#{shave_off}x0")
+        end
+      end
+      return image
+    end
+    
+    def run_system_command(command, error_message)
+      output = `#{command}`
+      raise "#{error_message}: error given #{$?}\n#{output}" if $? != 0
+      return output
+    end
+    
+  end
+  
+  # Configurations
+  Document::PROCESS_FORMAT = 'jpg'
+  
+  Document::PSD_EXT = '.psd'
+  Document::POSTSCRIPT_EXT = ['.pdf', '.eps', '.ai']
+  Document::IMAGE_EXT = ['.bmp', '.gif', '.jpg', '.jpeg', '.png', '.tga']
+
+end
+

data/lib/pruview/exceptions.rb

@@ -0,0 +1,8 @@
+module Pruview
+  module Exceptions
+  
+    class InvalidError < ::StandardError
+    end
+    
+  end
+end

data/lib/pruview/version.rb

@@ -0,0 +1,13 @@
+module Pruview
+  module Version
+    
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 1
+    
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    
+  end
+end

data/lib/pruview/video.rb

@@ -0,0 +1,130 @@
+module Pruview
+
+  class Video
+  
+    # this class assumes you have 'ffmpeg' and 'flvtool2' installed and in your path
+
+    def initialize(source, target_dir, bitrate_mult = 1)
+      raise Pruview::Exceptions::InvalidError, "Invalid source file:: #{source.to_s}" if !File.file?(source)
+      raise Pruview::Exceptions::InvalidError, "Invalid target directory: #{target_dir.to_s}" if !File.directory?(target_dir)
+      raise Pruview::Exceptions::InvalidError, "Video not supported - file extension: " + file_extension(source) if !format_supported?(source)
+      @source = source
+      @target_dir = target_dir
+      @bitrate_multiplier = bitrate_mult
+    end
+  
+    def to_flv(name, width, height, scale_static = false)
+      target = to_base(name, width, height, '.flv', scale_static)
+      run("#{FLVTOOL} -U #{target}", "Unable to add meta-data for #{target}.")
+      return target
+    end
+    
+    def to_mov(name, width, height, scale_static = false)
+      target = to_base(name, width, height, '.mov', scale_static)
+      # TODO: run qt-faststart
+      return target
+    end
+    
+  protected
+  
+    def to_base(name, width, height, extension, scale_static)
+      target = File.join(@target_dir, name.to_s + extension)
+      info_yml = File.join(@target_dir, name.to_s + '_info.yml')
+      run(build_command(@source, target, width, height, get_info(info_yml), scale_static), "Unable to convert #{@source} to #{target}.")
+      return target
+    end
+  
+    def format_supported?(source)
+      file_ext = file_extension(source)
+      EXT.each { |extension| return true if file_ext == extension }
+      return false
+    end
+    
+    def file_extension(source_file)
+       File.extname(source_file).downcase.chomp  
+    end
+    
+    def get_info(yml)
+      run("#{FFYML} #{@source} #{yml}", "Unable to get video info")
+      YAML.load_file(yml)
+    end
+  
+    def build_command(source, target, width, height, info, scale_static)
+      command = "#{FFMPEG} -i #{source}"
+      command += get_scale_command(info['width'], info['height'], width, height, scale_static)
+      scale_factor = get_scale_factor(info['width'], info['height'], width, height)
+      if file_extension(target) != '.flv' # use h264 codec with lower bitrate scaling factor
+        command += " -vcodec libx264" 
+        scale_factor /= 2.0
+      end
+      puts "scale factor: #{scale_factor.to_s}"
+      if !info['bitrate'].zero?
+        command += " -b #{(info['bitrate']*@bitrate_multiplier*scale_factor).to_s}"
+      else
+        command += " -sameq"
+      end
+      command += " -ab #{AUDIO_BITRATE}"
+      command += " -ar #{AUDIO_SAMPLING}"
+      command += " -y #{target}"
+    end
+    
+    def get_scale_factor(source_width, source_height, scale_width, scale_height)
+      if source_width > source_height
+        return (scale_width.to_f / source_width.to_f)
+      else
+        return (scale_height.to_f / source_height.to_f)
+      end
+    end
+    
+    def get_scale_command(source_width, source_height, scale_width, scale_height, static)
+      # this type of scaling assumes a static overall resolution with black padding added appropriately
+      # to keep the meaningful video area at the source aspect ratio
+      scale_params = get_scaling_params(source_width, source_height, scale_width, scale_height)
+      scale_command = " -s #{scale_params[:width].to_s}x#{scale_params[:height].to_s}"
+      if static == true
+        scale_command += " -padcolor #{PAD_COLOR}"
+        scale_command += " -padleft #{scale_params[:left]}" if scale_params[:left] > 0
+        scale_command += " -padtop #{scale_params[:top]}" if scale_params[:top] > 0
+        scale_command += " -padright #{scale_params[:right]}" if scale_params[:right] > 0
+        scale_command += " -padbottom #{scale_params[:bottom]}" if scale_params[:bottom] > 0
+      end
+      scale_command
+    end
+    
+    def get_scaling_params(source_width, source_height, scale_width, scale_height)
+      params = {}
+      params[:left],params[:top],params[:right],params[:bottom] = 0,0,0,0
+      params[:width],params[:height] = scale_width, scale_height
+      scale_aspect = scale_width.to_f / scale_height.to_f
+      source_aspect = source_width.to_f / source_height.to_f
+      if(source_aspect > scale_aspect)
+        params[:height] = (scale_width.to_f / source_aspect).to_i
+        params[:height] += 1 if params[:height] % 2 != 0
+        params[:top] = params[:bottom] = ((scale_height - params[:height]).to_f / 2).to_i
+        params[:top] = params[:bottom] += 1 if params[:top] % 2 != 0
+      elsif(source_aspect < scale_aspect)
+        params[:width] = (scale_height.to_f * source_aspect).to_i
+        params[:width] += 1 if params[:width] % 2 != 0
+        params[:left] = params[:right] = ((scale_width - params[:width]).to_f / 2).to_i
+        params[:left] = params[:right] += 1 if params[:left] % 2 != 0
+      end
+      return params
+    end
+
+    def run(command, error_message = "Unknown error.")
+      raise "Ffmpeg error: " + error_message + " - command: '#{command}'" if !system(command)
+    end
+  
+  # Configurations
+  Video::FFYML = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'ffyml'))
+  Video::FFMPEG = 'ffmpeg'
+  Video::FLVTOOL = 'flvtool2'
+  Video::PAD_COLOR = "000000"
+  Video::AUDIO_BITRATE = '128' # kbps
+  Video::AUDIO_SAMPLING = '44100'
+  
+  Video::EXT = ['.avi', '.flv', '.mov', '.mpg', '.mp4']
+
+  end
+end
+

data/lib/pruview/video_image.rb

@@ -0,0 +1,40 @@
+module Pruview
+  class VideoImage
+  
+    # this class assumes you have 'ffmpeg' installed and in your path
+
+    def self.to_jpg(source, target_dir, name)
+      raise Pruview::Exceptions::InvalidError, "Invalid source file:: #{source.to_s}" if !File.file?(source)
+      raise Pruview::Exceptions::InvalidError, "Invalid target directory: #{target_dir.to_s}" if !File.directory?(target_dir)
+      raise Pruview::Exceptions::InvalidError, "Video not supported - file extension: " + file_extension(source) if !format_supported?(source)
+      target = File.join(target_dir, name.to_s + '.jpg')
+      run(build_command(source, '-ss 00:00:00.2', 'mjpeg', target), "Unable to get preview image for #{target}")
+      # TODO: analyze image - create better
+      return target
+    end
+    
+  protected
+    
+    def self.format_supported?(source)
+      file_ext = file_extension(source)
+      Video::EXT.each { |extension| return true if file_ext == extension }
+      return false
+    end
+    
+    def self.file_extension(source_file)
+       File.extname(source_file).downcase.chomp  
+    end
+    
+    def self.build_command(source, time_str, format, target)
+      command = "#{Video::FFMPEG} -i #{source}"
+      command += " #{time_str}"
+      command += " -f #{format}" if !format.empty?
+      command += " -an -y #{target}"
+    end
+    
+    def self.run(command, error_message = "Unknown error.")
+      raise "Ffmpeg error: " + error_message + " - command: '#{command}'" if !system(command)
+    end
+  
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+# http://sneaq.net/textmate-wtf
+$:.reject! { |e| e.include? 'TextMate' }
+
+require 'rubygems'
+require 'test/unit'
+require 'matchy'
+require 'context'
+require 'mocha'
+
+require File.dirname(__FILE__) + '/../lib/pruview'

data/test/unit/pruview_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PruviewTest < Test::Unit::TestCase
+
+  describe "An instance of the Pruview class" do
+
+    it "should flunk" do
+      flunk "Please provide some tests"
+    end
+    
+  end
+
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: kelredd-pruview
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Kelly Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mini_magick
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: flvtool2
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: kelly@kelredd.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- features/document.feature
+- features/step_definitions
+- features/step_definitions/common_steps.rb
+- features/step_definitions/document_steps.rb
+- features/step_definitions/support
+- features/step_definitions/support/env.rb
+- features/step_definitions/support/helpers.rb
+- features/step_definitions/video_image_steps.rb
+- features/step_definitions/video_steps.rb
+- features/video.feature
+- features/video_image.feature
+- lib/pruview
+- lib/pruview/document.rb
+- lib/pruview/exceptions.rb
+- lib/pruview/sRGB.icm
+- lib/pruview/USWebCoatedSWOP.icc
+- lib/pruview/version.rb
+- lib/pruview/video.rb
+- lib/pruview/video_image.rb
+- lib/pruview.rb
+- test/files
+- test/files/basic.jpg
+- test/files/basic.mpg
+- test/files/error.jpg
+- test/files/error.mov
+- test/files/invalid_format.poop
+- test/test_helper.rb
+- test/unit
+- test/unit/pruview_test.rb
+has_rdoc: true
+homepage: ""
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A gem to ease generating image previews (thumbnails) of various files
+test_files: []
+