pdf_utils 0.1.0

data/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "pdf_utils"
+    gemspec.summary = "PdfUtils abstracts a lot of well working UNIX tools for PDF files"
+    gemspec.description = <<-DESC
+    Requires xpdf, pdftk, swftools/pdf2swf and imagemagick.
+    You can check their functionality by running `$ rake check_system_dependencies´.
+    DESC
+    gemspec.email = "l.rieder@gmail.com"
+    gemspec.homepage = "http://github.com/Overbryd/pdf_utils"
+    gemspec.authors = ["Lukas Rieder", "Andreas Korth"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_opts = ['--colour', '--format specdoc']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :check_system_dependencies do
+  load File.join(File.dirname(__FILE__), 'script', 'check_system_dependencies')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/in_tempdir.rb

@@ -0,0 +1,29 @@
+require 'tmpdir'
+
+module InTmpdir
+
+  private
+  
+  def in_tmpdir(dirname='tmp')
+    dirname = tmp_file_name(dirname)
+    FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+    begin
+      yield(dirname)
+    ensure
+      FileUtils.rm_rf(dirname) if File.exists?(dirname)
+    end
+  end
+  
+  def with_tmpfile(filename='tmp')
+    filename = tmp_file_name(filename)
+    begin
+      yield(filename)
+    ensure
+      FileUtils.rm_rf(filename) if File.exists?(filename)
+    end
+  end
+  
+  def tmp_file_name(name='tmp')
+    File.join(Dir.tmpdir, [$$.to_s(16), object_id.to_s(16), name].join('_'))
+  end
+end

data/lib/pdf_utils.rb

@@ -0,0 +1,175 @@
+require 'rubygems'
+require 'active_support'
+require 'prawn'
+require 'pdf/reader'
+
+require 'in_tempdir'
+require 'pdf_utils/info'
+require 'pdf_utils/color'
+
+module PdfUtils
+  
+  class << self
+    
+    include InTmpdir
+    
+    def objects(filename, filter={})
+      uncompress(filename) do |uncompressed|
+        PDF::Hash.new(uncompressed).values.select do |obj|
+          if obj.kind_of?(Hash)
+            if obj.has_key?(:Contents) && obj[:Contents].kind_of?(String)
+              obj[:Contents] = Iconv.conv('utf-8', 'utf-16', obj[:Contents]) 
+            end
+            filter.detect {|k, v| obj[k] == v }
+          end 
+        end
+      end
+    end
+    
+    def annotations(filename)
+      objects(filename, :Type => :Annot)
+    end
+    
+    def info(filename)
+      PdfUtils::Info.new(filename)
+    end
+    
+    def toc(filename)
+      toc = []
+      if meta_data = run_command(:pdftk, "#{filename} dump_data")
+        entry = nil
+        meta_data.scan(/^Bookmark(\w+): (.*)$/) do |(key, value)|
+          case key
+            when "Title"
+              entry = [value]
+            when "Level"
+              entry << value.to_i
+            when "PageNumber"
+              if value.to_i > 0
+                entry << value.to_i
+                toc << entry 
+              end
+          end
+        end
+      end
+      toc
+    end
+
+    def to_text(filename, target = nil)
+      run_command(:pdftotext, "-layout -enc UTF-8 #{filename} #{target || '-'}", !!target)
+    end
+    
+    def to_swf(source, target)
+      run_command(:pdf2swf, "-T 9 -f -s transparent -s detectspaces #{source} -o #{target}")
+    end
+    
+    def uncompress(source, target=nil, &block)
+      target ||= tmp_file_name("uncompress")
+      run_command(:pdftk, "#{source} output #{target} uncompress")
+      if block_given?
+        begin
+          yield(target)
+        ensure
+          FileUtils.rm(target)
+        end
+      end
+    end
+    
+    def slice(source, from_page, to_page, target)
+      run_command(:pdftk, "#{source} cat #{from_page}-#{to_page} output #{target}")
+    end
+    
+    def slice!(source, from_page, to_page)
+      target = tmp_file_name("slice")
+      slice(source, from_page, to_page, target)
+      FileUtils.mv(target, source)
+    end
+    
+    def burst(source, target)
+      run_command(:pdftk, "#{source} burst output #{target}")
+    end
+    
+    def cat(source, target)
+      run_command(:pdftk, "#{source} cat output #{target}")
+    end
+    
+    def watermark(source, target, options = {}, &block)
+      raise ArgumentError.new("No block given") unless block_given?
+      options[:page_size] ||= info(source).page_dimensions
+      with_tmpfile("watermark") do |watermarked|
+        Prawn::Document.generate(watermarked, options, &block)
+        run_command(:pdftk, "#{source} background #{watermarked} output #{target}")
+      end
+    end
+    
+    def watermark!(source, options = {}, &block)
+      target = tmp_file_name("watermark_merge")
+      watermark(source, target, options, &block)
+      FileUtils.mv(target, source)      
+    end
+
+    def annotate(source, annotations, target, options = {})
+      options[:page_size] ||= info(source).page_dimensions
+      with_tmpfile("annotate") do |annotated|
+        Prawn::Document.generate(annotated, options) do |pdf|
+          annotations.each do |annotation| 
+            pdf.annotate(annotation)
+          end
+        end
+        run_command(:pdftk, "#{annotated} background #{source} output #{target}")
+      end
+    end
+
+    def annotate!(source, annotations, options = {})
+      target = tmp_file_name("annotate_merge")
+      annotate(source, annotations, target, options)
+      FileUtils.mv(target, source)
+    end
+    
+    THUMBNAIL_DEFAULTS = { :density => 150, :size => '50%', :format => 'jpg', :quality => 85, :target => nil, :page => 1 }.freeze
+    
+    def thumbnail(source, options = {})
+      options.assert_valid_keys(THUMBNAIL_DEFAULTS.keys)
+
+      options = THUMBNAIL_DEFAULTS.merge(options)
+      target  = options[:target] || source.sub(/(\.\w+)?$/, ".#{options[:format]}")
+      source  = "#{source}[#{options[:page].to_i-1}]"
+      
+      run_command(:convert, [
+        '-density'          , options[:density],
+        source,
+        '-colorspace'       , :rgb,
+        '-thumbnail'        , options[:size],
+        '-quality'          , options[:quality],
+        target        
+      ].join(' '))
+      return target
+    end
+    
+    SNAPSHOT_DEFAULTS = { :density => 150, :compress => 'JPEG', :quality => 85 }.freeze
+    
+    def snapshot(source, target, options = {})
+      options.assert_valid_keys(SNAPSHOT_DEFAULTS.keys + [:page])
+      page_number = (options.delete(:page) || 1).to_i
+      source  = "#{source}[#{page_number-1}]"
+      options = SNAPSHOT_DEFAULTS.merge(options).map{ |opt,val| "-#{opt} #{val}" } << "#{source} #{target}"
+      run_command(:convert, options)
+    end
+    
+    def snapshot!(source, options = {})
+      snapshot(source, source, options)
+    end
+    
+    def run_command(command, args, reroute_errors = true)
+      command = [command, args]
+      command << '2>&1' if reroute_errors
+      command = command.join(' ')
+      output = `#{command}`
+      if $?.success?
+        output
+      else
+        raise RuntimeError.new("Command failed: #{command}\n#{output}")
+      end
+    end
+  end
+end

data/lib/pdf_utils/color.rb

@@ -0,0 +1,27 @@
+module PdfUtils
+  class Color
+    def initialize(*args)
+      if args.first.is_a?(String)
+        @r, @g, @b = args.first.scan(/../).map{ |rgb| rgb.to_i(16) }
+      elsif args.size == 3
+        if args.any? {|arg| arg.kind_of?(Float) }
+          @r, @g, @b = args.map {|v| (v * 255).to_i }
+        else
+          @r, @g, @b = args
+        end
+      end
+    end
+    
+    def to_pdf
+      to_rgb.map{ |v| v / 255.0 }
+    end
+    
+    def to_hex
+      to_rgb.inject(''){ |hex, v| hex << "%02x" % v }
+    end
+    
+    def to_rgb
+      [@r, @g, @b]
+    end
+  end
+end

data/lib/pdf_utils/info.rb

@@ -0,0 +1,46 @@
+module PdfUtils
+  class Info
+    attr_reader :pdf_version, :title, :author, :subject, :keywords, :creator, :producer, :tagged, :optimized, :encrypted
+    attr_reader :file_size, :mod_date, :creation_date, :pages, :page_size, :page_format
+    alias_method :tagged?, :tagged
+    alias_method :optimized?, :optimized
+    alias_method :encrypted?, :encrypted
+    alias_method :modification_date, :mod_date
+    
+    def initialize(filename)
+      raise ArgumentError.new("File does not exist: #{filename}") unless File.exist?(filename)
+      info = {}
+      PdfUtils::run_command(:pdfinfo, filename).scan(/^([^:]+): +(.*?)?$/) do |property|
+        info.store(*property)
+      end
+      @pdf_version   = info["PDF version"]
+      @title         = info["Title"]
+      @subject       = info["Subject"]
+      @keywords      = info["Keywords"]
+      @author        = info["Author"]
+      @creator       = info["Creator"]
+      @producer      = info["Producer"]
+      @pages         = info["Pages"].to_i
+      @creation_date = Time.parse(info["CreationDate"]) rescue nil
+      @mod_date      = Time.parse(info["ModDate"]) rescue nil
+      @page_size     = info["Page size"] =~ /^([\d.]+) x ([\d.]+)/ && [$1.to_f, $2.to_f]
+      @page_format   = info["Page size"] =~ /\(([^(]+)\)$/ && $1
+      @file_size     = info["File size"] =~ /^(\d+) bytes$/ && $1.to_i
+      @optimized     = info["Optimized"] == 'yes'
+      @tagged        = info["Tagged"] == 'yes'
+      @encrypted     = info["Encrypted"] == 'yes'
+    end
+    
+    def page_dimensions
+      [page_width, page_height]
+    end
+    
+    def page_width
+      @page_size[0]
+    end
+
+    def page_height
+      @page_size[1]
+    end
+  end
+end

data/script/check_system_dependencies

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), '../lib'))
+require 'pdf_utils'
+
+tmpdir = File.join(Dir.tmpdir, "#{$$}-dependency_checks")
+FileUtils.mkdir(tmpdir) rescue nil
+
+root = File.join(File.dirname(__FILE__), '../')
+checkfile = File.join(tmpdir, 'check.pdf')
+FileUtils.cp(File.join(root, 'spec/fixtures/marketing.pdf'), checkfile)
+
+def check(what, &block)
+  print "Checking #{what}... "
+  yield
+  if $?.success?
+    puts "passed."
+  else
+    puts "failed."
+  end
+end
+
+check 'pdf info' do
+  PdfUtils::info(checkfile)
+end
+
+check 'pdf table of contents' do
+  PdfUtils::toc(checkfile)
+end
+
+check 'pdf to text' do
+  PdfUtils::to_text(checkfile)
+end
+
+check 'pdf uncompress' do
+  PdfUtils::uncompress(checkfile)
+end
+
+check 'pdf to swf' do
+  PdfUtils::to_swf(checkfile, File.join(tmpdir, 'check.swf'))
+end
+
+check 'pdf slicing' do
+  PdfUtils::slice(checkfile, 1, 2, File.join(tmpdir, 'sliced.pdf'))
+end
+
+check 'pdf bursting' do
+  PdfUtils::burst(checkfile, File.join(tmpdir, 'burst-%04d.pdf'))
+end
+
+check 'pdf background' do
+  PdfUtils::watermark(checkfile, File.join(tmpdir, 'watermarked.pdf'), :margin => 0) do |page|
+    page.text 'I am watermarked'
+  end
+end
+
+check 'pdf to cover' do
+  PdfUtils::thumbnail(checkfile, :target => File.join(tmpdir, 'cover.jpg'))
+end
+
+check 'pdf to snapshot' do
+  PdfUtils::snapshot(checkfile, File.join(tmpdir, 'snapshot.pdf'))
+end

data/spec/pdf_utils/color_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe PdfUtils::Color do
+  it "should convert to pdf color" do
+    PdfUtils::Color.new(255, 255, 0).to_pdf.should eql([1.0, 1.0, 0.0])
+  end
+  
+  it "should convert to hex color" do
+    PdfUtils::Color.new(0, 1.0, 0).to_hex.should eql('00ff00')
+  end
+  
+  it "should convert to rgb values" do
+    PdfUtils::Color.new('ff0000').to_rgb.should eql([255, 0, 0])
+  end
+end

data/spec/pdf_utils/info_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe PdfUtils::Info do
+  it "should extract meta information from the pdf" do
+    @info = PdfUtils::Info.new(fixture_file_path('marketing.pdf'))
+    
+    @info.tagged        .should eql(false)
+    @info.keywords      .should eql("")
+    @info.page_size     .should eql([595.0, 842.0])
+    @info.producer      .should eql("Mac OS X 10.5.6 Quartz PDFContext")
+    @info.optimized     .should eql(false)
+    @info.title         .should eql("marketing")
+    @info.mod_date      .should eql(Time.parse('2010/01/12 17:34:51 +0100'))
+    @info.creator       .should eql("Preview")
+    @info.file_size     .should eql(33179)
+    @info.pdf_version   .should eql("1.4")
+    @info.creation_date .should eql(Time.parse('2009/02/04 13:42:55 +0100'))
+    @info.encrypted     .should eql(false)
+    @info.author        .should eql("Alexander Lang")
+    @info.page_format   .should eql("A4")
+    @info.pages         .should eql(3)
+    @info.subject       .should eql("")
+  end
+end

data/spec/pdf_utils_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe PdfUtils do
+  
+  describe "toc" do
+
+    it "should return an array of toc entries" do
+      PdfUtils.should_receive(:run_command).with(:pdftk, "stub.pdf dump_data").and_return(
+        "BookmarkTitle: Content\nBookmarkLevel: 1\nBookmarkPageNumber: 3\nBookmarkTitle: Intro\nBookmarkLevel: 2\nBookmarkPageNumber: 4")
+      PdfUtils::toc('stub.pdf').should eql([["Content",1,3], ["Intro",2,4]])
+    end
+    
+    it "should not add an toc entry with page number < 1" do
+      PdfUtils.stub(:run_command => "BookmarkTitle: Content\nBookmarkLevel: 1\nBookmarkPageNumber: 0")
+      PdfUtils::toc('stub.pdf').should be_empty
+    end
+
+    it "should be empty if the document has no toc data" do
+      PdfUtils.should_receive(:run_command).with(:pdftk, "stub.pdf dump_data").and_return(
+        "InfoKey: Creator\nInfoValue: The Pragmatic Bookshelf")
+      PdfUtils::toc('stub.pdf').entries.should be_empty
+    end
+  end
+
+  describe "slice" do
+    
+    it "should slice into a new pdf" do
+      sliced_path = Tempfile.new('sliced').path
+      PdfUtils::slice(fixture_file_path('marketing.pdf'), 2, 3, sliced_path)
+      PdfUtils::info(sliced_path).pages.should eql(2)
+    end
+    
+    it "should slice the given file" do
+      sliced_path = duplicate_fixture_file('marketing.pdf').path
+      PdfUtils::slice!(sliced_path, 2, 3)
+      PdfUtils::info(sliced_path).pages.should eql(2)
+    end
+    
+    it "should raise an error if pdftk fails to slice the pdf" do
+      lambda {
+        PdfUtils::slice('does/not/exist.pdf', 2, 3, 'does/not/exist/either.pdf')
+      }.should raise_error(RuntimeError)
+    end
+  end
+  
+  describe "watermark" do
+    
+    before :each do
+      @pdf_path = fixture_file_path('marketing.pdf')
+    end
+
+    it "should watermark into a new pdf" do
+      watermarked_path = Tempfile.new('watermarked').path
+      PdfUtils::watermark(@pdf_path, watermarked_path) do |pdf|
+        pdf.text "WATERMARKED PDF", :align => :center, :size => 8
+      end
+      pdf_text = PdfUtils::to_text(watermarked_path)
+      pdf_text.should include('WATERMARKED PDF')
+      pdf_text.should include('Beltz Verlag Weinheim')
+    end
+    
+    it "should watermark the given file" do
+      watermarked_path = duplicate_fixture_file('marketing.pdf').path
+      PdfUtils::watermark!(watermarked_path) do |pdf|
+        pdf.text "WATERMARKED PDF", :align => :center, :size => 8
+      end
+      pdf_text = PdfUtils::to_text(watermarked_path)
+      pdf_text.should include('WATERMARKED PDF')
+      pdf_text.should include('Beltz Verlag Weinheim')
+    end
+    
+    it "should pass options to the watermark pdf" do
+      Prawn::Document.should_receive(:generate).with(anything, :page_size => [25, 25])
+      PdfUtils::watermark(@pdf_path, Tempfile.new('target').path, :page_size => [25, 25]) {}
+    end
+  end
+  
+  describe "annotate" do
+    
+    before :each do
+      @pdf_path = fixture_file_path('page.pdf')
+      @annotations = [{
+        :Type     => :Annot,
+        :Subtype  => :Text,
+        :Name     => :Comment,
+        :Rect     => [10, 10, 34, 34],
+        :Contents => 'Dies ist eine Notiz.',
+        :C        => PdfUtils::Color.new('fdaa00').to_pdf,
+        :M        => Time.now,
+        :F        => 4
+      }]
+    end
+    
+    it "should annotate into a new pdf" do
+      annotated_path = Tempfile.new('annotated').path
+      PdfUtils::annotate(@pdf_path, @annotations, annotated_path)
+      annotations = PdfUtils::annotations(annotated_path)
+      annotations.should have(1).item
+      annotations.first[:Contents].should eql('Dies ist eine Notiz.')
+    end
+  end
+
+  describe "thumbnail" do
+
+    it "should create a thumbnail of the given page" do
+      source = fixture_file_path('marketing.pdf')
+      target = File.join(Dir.tmpdir, 'marketing.png')
+      FileUtils.rm(target) if File.exists?(target)
+      PdfUtils::thumbnail(source, :page => '3', :target => target)
+      File.should be_exists(target)
+    end
+  end
+  
+  describe "snapshot" do
+
+    it "should rasterize the given page" do
+      path = duplicate_fixture_file('marketing.pdf').path
+      original_info = PdfUtils::info(path)
+
+      PdfUtils::snapshot!(path, :page => 2)
+
+      info = PdfUtils::info(path)
+      info.pages.should eql(1)
+      info.page_width. should be_close(original_info.page_width , 1.0)
+      info.page_height.should be_close(original_info.page_height, 1.0)
+      info.page_format.should eql(original_info.page_format)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require 'test/unit'
+require "spec"
+require 'tempfile'
+
+require 'pdf_utils'
+
+def fixture_file_path(file)
+  File.join(File.dirname(__FILE__), 'fixtures', file)
+end
+
+def fixture_file(file)
+  File.open(fixture_file_path(file))
+end
+
+def duplicate_fixture_file(file)
+  tempfile = Tempfile.new(File.basename(file))
+  FileUtils.cp_r(fixture_file_path(file), tempfile.path)
+  tempfile
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: pdf_utils
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Lukas Rieder
+- Andreas Korth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-03 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: "    Requires xpdf, pdftk, swftools/pdf2swf and imagemagick.\n    You can check their functionality by running `$ rake check_system_dependencies\xC2\xB4.\n"
+email: l.rieder@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- VERSION
+- lib/in_tempdir.rb
+- lib/pdf_utils.rb
+- lib/pdf_utils/color.rb
+- lib/pdf_utils/info.rb
+- script/check_system_dependencies
+- spec/fixtures/marketing.pdf
+- spec/fixtures/page.pdf
+- spec/pdf_utils/color_spec.rb
+- spec/pdf_utils/info_spec.rb
+- spec/pdf_utils_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/Overbryd/pdf_utils
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: PdfUtils abstracts a lot of well working UNIX tools for PDF files
+test_files: 
+- spec/pdf_utils/color_spec.rb
+- spec/pdf_utils/info_spec.rb
+- spec/pdf_utils_spec.rb
+- spec/spec_helper.rb