docsplit 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Jeremy Ashkenas, DocumentCloud
+
+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/README

@@ -0,0 +1,22 @@
+==
+         __                      ___ __ 
+    ____/ /___  ______________  / (_) /_
+   / __  / __ \/ ___/ ___/ __ \/ / / __/
+  / /_/ / /_/ / /__(__  ) /_/ / / / /_  
+  \____/\____/\___/____/ .___/_/_/\__/  
+                      /_/
+                      
+  Docsplit is a command-line utility and Ruby library for splitting apart
+  documents into their component parts: searchable UTF-8 plain text, page 
+  images or thumbnails in any format, PDFs, single pages, and document 
+  metadata (title, author, number of pages...)
+  
+  Installation:
+  gem install docsplit
+  
+  For documentation, usage, and examples, see:
+  http://documentcloud.github.com/docsplit/
+  
+  To suggest a feature or report a bug: 
+  http://github.com/documentcloud/docsplit/issues/
+

data/bin/docsplit

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "#{File.dirname(__FILE__)}/../lib/docsplit/command_line.rb"
+
+Docsplit::CommandLine.new

data/docsplit.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name      = 'docsplit'
+  s.version   = '0.1.0'         # Keep version in sync with jammit.rb
+  s.date      = '2009-12-07'
+
+  s.homepage    = "http://documentcloud.github.com/docsplit/"
+  s.summary     = "Break Apart Documents into Images, Text, Pages and PDFs"
+  s.description = <<-EOS
+    Docsplit is a command-line utility and Ruby library for splitting apart
+    documents into their component parts: searchable UTF-8 plain text, page
+    images or thumbnails in any format, PDFs, single pages, and document
+    metadata (title, author, number of pages...)
+  EOS
+
+  s.authors           = ['Jeremy Ashkenas']
+  s.email             = 'jeremy@documentcloud.org'
+  s.rubyforge_project = 'docsplit'
+  s.has_rdoc          = false
+
+  s.require_paths     = ['lib']
+  s.executables       = ['docsplit']
+
+  s.files = Dir['build/**/*', 'lib/**/*', 'bin/*', 'vendor/**/*',
+                'docsplit.gemspec', 'LICENSE', 'README']
+end

data/lib/docsplit/ExtractInfo.java

@@ -0,0 +1,63 @@
+package org.documentcloud;
+
+import java.util.List;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDDocumentInformation;
+
+// Extracts metadata from a PDF file.
+public class ExtractInfo extends Extractor {
+
+  private PDDocument doc;
+  private PDDocumentInformation info;
+  private String key;
+
+  // The list of metadata keys we know how to extract.
+  private enum Keys {
+    AUTHOR, DATE, CREATOR, KEYWORDS, PRODUCER, SUBJECT, TITLE, LENGTH
+  }
+
+  // The mainline.
+  public static void main(String[] args) {
+    (new ExtractInfo()).run(args);
+  }
+
+  // The first argument is always the name of the metadata key.
+  protected void parseArguments(List<String> args) {
+    super.parseArguments(args);
+    key = args.remove(0).toUpperCase();
+  }
+
+  // Extract the configured bit of metadata from a PDF, decrypting if necessary.
+  public void extract(String pdfPath) {
+    try {
+      doc = PDDocument.load(pdfPath, false);
+      decrypt(doc);
+      info = doc.getDocumentInformation();
+      String val = extractInfo();
+      if (val != null) System.out.println(val);
+      doc.close();
+    } catch(IOException e) {
+      System.out.println(e.getMessage());
+      System.exit(1);
+    }
+  }
+
+  // Use the PDDocumentInformation object to fetch metadata values as strings.
+  public String extractInfo() throws IOException {
+    switch(Keys.valueOf(key)) {
+      case AUTHOR:    return info.getAuthor();
+      case DATE:      return new SimpleDateFormat("yyyy-MM-dd").format(info.getCreationDate().getTime());
+      case CREATOR:   return info.getCreator();
+      case KEYWORDS:  return info.getKeywords();
+      case PRODUCER:  return info.getProducer();
+      case SUBJECT:   return info.getSubject();
+      case TITLE:     return info.getTitle();
+      case LENGTH:    return String.valueOf(doc.getNumberOfPages());
+      default:        return null;
+    }
+  }
+
+}

data/lib/docsplit/ExtractPages.java

@@ -0,0 +1,54 @@
+package org.documentcloud;
+
+import java.util.List;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.util.Splitter;
+import org.apache.pdfbox.pdfwriter.COSWriter;
+import org.apache.pdfbox.exceptions.COSVisitorException;
+
+// Use PDFBox's Splitter to break apart a large PDF into individual pages.
+public class ExtractPages extends Extractor {
+
+  private PDDocument doc;
+  private String basename;
+
+  // The mainline.
+  public static void main(String[] args) {
+    (new ExtractPages()).run(args);
+  }
+
+  // Extract each page of the given PDF.
+  public void extract(String pdfPath) {
+    try {
+      basename  = getBasename(pdfPath);
+      doc = PDDocument.load(pdfPath);
+      decrypt(doc);
+      List pages = (new Splitter()).split(doc);
+      if (pageNumbers != null) {
+        for (Integer num : pageNumbers) writePage((PDDocument) pages.get(num.intValue()- 1), num.intValue());
+      } else {
+        for (int i=0; i<pages.size(); i++) writePage((PDDocument) pages.get(i), i + 1);
+      }
+      doc.close();
+    } catch(Exception e) {
+      System.out.println(e.getMessage());
+      System.exit(1);
+    }
+  }
+
+  // Writes out a page as a single-page PDF.
+  private void writePage(PDDocument page, int pageNumber) throws IOException, COSVisitorException {
+    String pageName       = basename + "_" + String.valueOf(pageNumber) + ".pdf";
+    FileOutputStream out  = new FileOutputStream(outputFile(pageName));
+    COSWriter writer      = new COSWriter(out);
+    writer.write(page);
+    out.close();
+    writer.close();
+    page.close();
+  }
+
+}

data/lib/docsplit/ExtractText.java

@@ -0,0 +1,80 @@
+package org.documentcloud;
+
+import java.util.List;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.util.PDFTextStripper;
+
+// Uses PDFBox's PDFTextStripper to extract the full, plain, UTF-8 text of a
+// PDF document. Pass --pages to write out the plain text for each individual
+// page; --pages-only to omit the text for the entire document.
+public class ExtractText extends Extractor {
+
+  private PDDocument doc;
+  private String basename;
+
+  // The mainline.
+  public static void main(String[] args) {
+    (new ExtractText()).run(args);
+  }
+
+  // Extract the plain text for a PDF, and write it into the requested output
+  // sizes.
+  public void extract(String pdfPath) {
+    try {
+      basename = getBasename(pdfPath);
+      doc = PDDocument.load(pdfPath, false);
+      decrypt(doc);
+      if (allPages || (pageNumbers != null)) {
+        writePageText();
+      } else {
+        writeFullText();
+      }
+      doc.close();
+    } catch(IOException e) {
+      System.out.println(e.getMessage());
+      System.exit(1);
+    }
+  }
+
+  // Write out the extracted full text for the entire PDF.
+  public void writeFullText() throws IOException {
+    OutputStreamWriter output = new OutputStreamWriter(new FileOutputStream(outputFile(basename + ".txt")), "UTF-8");
+    extractTextForPageRange(output, 1, Integer.MAX_VALUE);
+    output.close();
+  }
+
+  // Write out the full text for each specified page.
+  public void writePageText() throws IOException {
+    if (pageNumbers != null) {
+      for (Integer num : pageNumbers) writePageText(num.intValue());
+    } else {
+      int pages = doc.getNumberOfPages();
+      for (int i=1; i<=pages; i++) writePageText(i);
+    }
+  }
+
+  // Write out the full text for a single page.
+  public void writePageText(int pageNumber) throws IOException {
+    File outfile = outputFile(basename + "_" + String.valueOf(pageNumber) + ".txt");
+    OutputStreamWriter output = new OutputStreamWriter(new FileOutputStream(outfile), "UTF-8");
+    extractTextForPageRange(output, pageNumber, pageNumber);
+    output.close();
+  }
+
+  // Internal method to writes out text from the PDF for a given page range
+  // to a provided output stream.
+  private void extractTextForPageRange(OutputStreamWriter output, int startPage, int endPage) throws IOException {
+    PDFTextStripper stripper = new PDFTextStripper("UTF-8");
+    stripper.setSortByPosition(false);
+    stripper.setShouldSeparateByBeads(true);
+    stripper.setStartPage(startPage);
+    stripper.setEndPage(endPage);
+    stripper.writeText(doc, output);
+  }
+
+}

data/lib/docsplit/Extractor.java

@@ -0,0 +1,91 @@
+package org.documentcloud;
+
+import java.io.File;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+
+// The base Extractor class contains the common functionality needed to run
+// command-line extractors.
+public abstract class Extractor {
+
+  protected File output;
+  protected boolean allPages = false;
+  protected ArrayList<Integer> pageNumbers;
+
+  // Running an extractor consists of converting the arguments array into a
+  // more manageable List, parsing arguments, and extracting pdfs.
+  public void run(String[] arguments) {
+    List<String> args = new ArrayList<String>(Arrays.asList(arguments));
+    parseArguments(args);
+    Iterator<String> iter = args.iterator();
+    while(iter.hasNext()) extract(iter.next());
+  }
+
+  // Subclasses must override "extract" to perform their specific extraction.
+  public abstract void extract(String pdfPath);
+
+  // The default "parseArguments" method handles common arguments.
+  protected void parseArguments(List<String> args) {
+    int dirLoc = args.indexOf("--output");
+    if (dirLoc >= 0) {
+      output = new File(args.remove(dirLoc + 1));
+      args.remove(dirLoc);
+    }
+    int pagesLoc = args.indexOf("--pages");
+    if (pagesLoc >= 0) {
+      parsePages(args.remove(pagesLoc + 1));
+      args.remove(pagesLoc);
+    }
+  }
+
+  // Utility function to get the basename of a file path.
+  // After File.basename in Ruby.
+  public String getBasename(String pdfPath) {
+    String basename = new File(pdfPath).getName();
+    return basename.substring(0, basename.lastIndexOf('.'));
+  }
+
+  // Get a reference to an output file, placed inside any configured directories,
+  // while ensuring that parent directories exist.
+  public File outputFile(String path) {
+    File file = output != null ? new File(output, path) : new File(path);
+    File parent = file.getParentFile();
+    if (parent != null) parent.mkdirs();
+    return file;
+  }
+
+  // Decrypt a non-passworded but still encrypted document.
+  public void decrypt(PDDocument doc) {
+    if (!doc.isEncrypted()) return;
+    try {
+      doc.decrypt("");
+    } catch (Exception e) {
+      System.out.println("Error decrypting document, details: " + e.getMessage());
+      System.exit(1);
+    }
+  }
+
+  private void parsePages(String pageList) {
+    if (pageList.equals("all")) {
+      allPages = true;
+      return;
+    }
+    pageNumbers = new ArrayList<Integer>();
+    String[] groups = pageList.split(",");
+    for (String group : groups) {
+      if (group.contains("-")) {
+        String[] range = group.split("-");
+        int start = Integer.parseInt(range[0]);
+        int end = Integer.parseInt(range[1]);
+        for (int i=start; i<=end; i++) pageNumbers.add(new Integer(i));
+      } else {
+        pageNumbers.add(new Integer(Integer.parseInt(group)));
+      }
+    }
+  }
+
+}

data/lib/docsplit/argument_parser.rb

@@ -0,0 +1,31 @@
+module Docsplit
+
+  module ArgumentParser
+
+    # Flatten an options hash into an arguments string suitable for the command
+    # line.
+    def parse_options(opts)
+      opts.map {|k, v| ["--#{k}", normalize_value(v)] }.flatten.join(' ')
+    end
+
+    # Normalize a value in an options hash for the command line.
+    # Ranges look like: 1-10, Arrays like: 1,2,3.
+    def normalize_value(value)
+      case value
+      when Range then normalize_range(value)
+      when Array then value.map! {|v| v.is_a?(Range) ? normalize_range(v) : v }.join(',')
+      else            value.to_s
+      end
+    end
+
+    # Serialize a Ruby range into it's command-line equivalent.
+    def normalize_range(range)
+      arr = range.to_a
+      arr.empty? ? range.first.to_s : "#{range.first}-#{arr.last}"
+    end
+
+  end
+
+  extend ArgumentParser
+
+end

data/lib/docsplit/command_line.rb

@@ -0,0 +1,107 @@
+require 'optparse'
+require File.expand_path(File.dirname(__FILE__) + '/../docsplit')
+
+module Docsplit
+
+  # A single command-line utility to separate a PDF into all its component parts.
+  class CommandLine
+
+    BANNER = <<-EOS
+docsplit breaks apart documents into images, text, or individual pages.
+It wraps PDFBox, GraphicsMagick, and JODConverter.
+
+Usage:
+  docsplit COMMAND [OPTIONS] path/to/doc.pdf
+  Main commands:
+    pages, images, text, pdf.
+  Metadata commands:
+    author, date, creator, keywords, producer, subject, title, length.
+
+Example:
+  docsplit images --size 700x --format jpg document.pdf
+
+Dependencies:
+  Ruby, Java, A working GraphicsMagick (gm) command,
+  and a headless OpenOffice server for non-PDF documents.
+
+Options:
+    (size, pages and format can take comma-separated values)
+
+    EOS
+
+    # Creating a CommandLine runs off of the contents of ARGV.
+    def initialize
+      parse_options
+      cmd = ARGV.shift
+      @command = cmd && cmd.to_sym
+      run
+    end
+
+    # Delegate to the Docsplit Ruby API to perform all extractions.
+    def run
+      begin
+        case @command
+        when :images  then Docsplit.extract_images(ARGV, @options)
+        when :pages   then Docsplit.extract_pages(ARGV, @options)
+        when :text    then Docsplit.extract_text(ARGV, @options)
+        when :pdf     then Docsplit.extract_pdf(ARGV, @options)
+        else
+          if METADATA_KEYS.include?(@command)
+            value = Docsplit.send("extract_#{@command}", ARGV, @options)
+            puts value unless value.nil?
+          else
+            usage
+          end
+        end
+      rescue ExtractionFailed => e
+        puts e.message.chomp
+        exit(1)
+      end
+    end
+
+    # Print out the usage help message.
+    def usage
+      puts "\n#{@option_parser}\n"
+      exit
+    end
+
+
+    private
+
+    # Use the OptionParser library to parse out all supported options. Return
+    # options formatted for the Ruby API.
+    def parse_options
+      @options = {}
+      @option_parser = OptionParser.new do |opts|
+        opts.on('-o', '--output [DIR]', 'set the directory for all output') do |d|
+          @options[:output] = d
+        end
+        opts.on('-p', '--pages [PAGES]', "extract specific pages (eg: 5-10)") do |p|
+          @options[:pages] = p
+        end
+        opts.on('-s', '--size [SIZE]', 'set a fixed size (eg: 50x75)') do |s|
+          @options[:size] = s.split(',')
+        end
+        opts.on('-f', '--format [FORMAT]', 'set image format (pdf, jpg, gif...)') do |t|
+          @options[:format] = t.split(',')
+        end
+        opts.on_tail('-v', '--version', 'display docsplit version') do
+          puts "docsplit version #{Docsplit::VERSION}"
+          exit
+        end
+        opts.on_tail('-h', '--help', 'display this help message') do
+          usage
+        end
+      end
+      @option_parser.banner = BANNER
+      begin
+        @option_parser.parse!(ARGV)
+      rescue OptionParser::InvalidOption => e
+        puts e.message
+        exit(1)
+      end
+    end
+
+  end
+
+end

data/lib/docsplit/image_extractor.rb

@@ -0,0 +1,94 @@
+module Docsplit
+
+  # Delegates to GraphicsMagick in order to convert PDF documents into
+  # nicely sized images.
+  class ImageExtractor
+
+    DENSITY_ARG = "-density 150"
+    DEFAULT_FORMAT = :png
+
+    # Extract a list of PDFs as rasterized page images, according to the
+    # configuration in options.
+    def extract(pdfs, options)
+      @pdfs = [pdfs].flatten
+      extract_options(options)
+      @pdfs.each {|p| @sizes.each {|s| @formats.each {|f| convert(p, s, f) }}}
+    end
+
+    # Convert a single PDF into page images at the specified size and format.
+    def convert(pdf, size, format)
+      basename  = File.basename(pdf, File.extname(pdf))
+      subfolder = @sizes.length > 1 ? size.to_s : ''
+      directory = File.join(@output, subfolder)
+      FileUtils.mkdir_p(directory) unless File.exists?(directory)
+      out_file  = File.join(directory, "#{basename}_%05d.#{format}")
+      cmd = "gm convert #{DENSITY_ARG} #{resize_arg(size)} #{quality_arg(format)} \"#{pdf}#{pages_arg}\" \"#{out_file}\" 2>&1"
+      result = `#{cmd}`.chomp
+      raise ExtractionFailed, result if $? != 0
+      renumber_images(out_file, format)
+    end
+
+
+    private
+
+    # Extract the relevant GraphicsMagick options from the options hash.
+    def extract_options(options)
+      @output  = options[:output]  || '.'
+      @pages   = options[:pages]
+      @formats = [options[:format] || DEFAULT_FORMAT].flatten
+      @sizes   = [options[:size]].flatten.compact
+      @sizes   = [nil] if @sizes.empty?
+    end
+
+    # Generate the resize argument.
+    def resize_arg(size)
+      size.nil? ? '' : "-resize #{size}"
+    end
+
+    # Generate the appropriate quality argument for the image format.
+    def quality_arg(format)
+      case format.to_s
+      when /jpe?g/ then "-quality 85"
+      when /png/   then "-quality 100"
+      else ""
+      end
+    end
+
+    # Generate the requested page index into the document.
+    def pages_arg
+      return '' if @pages.nil?
+      pages = @pages.gsub(/\d+/) {|digits| (digits.to_i - 1).to_s }
+      "[#{pages}]"
+    end
+
+    # Generate the expanded list of requested page numbers.
+    def page_list
+      @pages.split(',').map { |range|
+        if range.include?('-')
+          range = range.split('-')
+          Range.new(range.first, range.last).to_a.map {|n| n.to_i }
+        else
+          range.to_i
+        end
+      }.flatten.sort
+    end
+
+    # When GraphicsMagick is through, it will have generated a number of
+    # incrementing page images, starting at 0. Renumber them with their correct
+    # page numbers.
+    def renumber_images(template, format)
+      suffixer = /_0+(\d+)\.#{format}\Z/
+      images = Dir[template.sub('%05d', '0*')].map do |path|
+        index = path[suffixer, 1].to_i
+        {:path => path, :index => index, :page_number => index + 1}
+      end
+      numbers = @pages ? page_list.reverse : nil
+      images.sort_by {|i| -i[:page_number] }.each_with_index do |image, i|
+        number = numbers ? numbers[i] : image[:page_number]
+        FileUtils.mv(image[:path], image[:path].sub(suffixer, "_#{number}.#{format}"))
+      end
+    end
+
+  end
+
+end

data/lib/docsplit/transparent_pdfs.rb

@@ -0,0 +1,26 @@
+module Docsplit
+
+  # Include a method to transparently convert non-PDF arguments to temporary
+  # PDFs. Allows us to pretend to natively support docs, rtf, ppt, and so on.
+  module TransparentPDFs
+
+    # Temporarily convert any non-PDF documents to PDFs before running them
+    # through further extraction.
+    def ensure_pdfs(docs)
+      [docs].flatten.map do |doc|
+        ext = File.extname(doc)
+        if ext == '.pdf'
+          doc
+        else
+          @tempdir ||= File.join(Dir.tmpdir, 'docsplit')
+          extract_pdf([doc], {:output => @tempdir})
+          File.join(@tempdir, File.basename(doc, ext) + '.pdf')
+        end
+      end
+    end
+
+  end
+
+  extend TransparentPDFs
+
+end

data/lib/docsplit.rb

@@ -0,0 +1,78 @@
+# The Docsplit module delegates to the Java PDF extractors.
+module Docsplit
+
+  VERSION       = '0.1.0' # Keep in sync with gemspec.
+
+  ROOT          = File.expand_path(File.dirname(__FILE__) + '/..')
+
+  CLASSPATH     = "#{ROOT}/build#{File::PATH_SEPARATOR}#{ROOT}/vendor/'*'"
+
+  LOGGING       = "-Djava.util.logging.config.file=#{ROOT}/vendor/logging.properties"
+
+  HEADLESS      = "-Djava.awt.headless=true"
+
+  METADATA_KEYS = [:author, :date, :creator, :keywords, :producer, :subject, :title, :length]
+
+  # Raise an ExtractionFailed exception when the PDF is encrypted, or otherwise
+  # broke.
+  class ExtractionFailed < StandardError; end
+
+  # Use the ExtractPages Java class to burst a PDF into single pages.
+  def self.extract_pages(pdfs, opts={})
+    pdfs = ensure_pdfs(pdfs)
+    run "org.documentcloud.ExtractPages", pdfs, opts
+  end
+
+  # Use the ExtractText Java class to write out all embedded text.
+  def self.extract_text(pdfs, opts={})
+    pdfs = ensure_pdfs(pdfs)
+    run "org.documentcloud.ExtractText", pdfs, opts
+  end
+
+  # Use the ExtractImages Java class to rasterize a PDF into each page's image.
+  def self.extract_images(pdfs, opts={})
+    pdfs = ensure_pdfs(pdfs)
+    opts[:pages] = normalize_value(opts[:pages]) if opts[:pages]
+    ImageExtractor.new.extract(pdfs, opts)
+  end
+
+  # Use JODCConverter to extract the documents as PDFs.
+  def self.extract_pdf(docs, opts={})
+    [docs].flatten.each do |doc|
+      basename = File.basename(doc, File.extname(doc))
+      run "-jar #{ROOT}/vendor/jodconverter/jodconverter-cli-2.2.2.jar #{doc} #{opts[:output] || '.'}/#{basename}.pdf", [], {}
+    end
+  end
+
+  # Define custom methods for each of the metadata keys that we support.
+  # Use the ExtractInfo Java class to print out a single bit of metadata.
+  METADATA_KEYS.each do |key|
+    instance_eval <<-EOS
+      def self.extract_#{key}(pdfs, opts={})
+        pdfs = ensure_pdfs(pdfs)
+        result = run "org.documentcloud.ExtractInfo #{key}", pdfs, opts, true
+        :#{key} == :length ? result.to_i : result
+      end
+    EOS
+  end
+
+
+  private
+
+  # Runs a Java command, with quieted logging, and the classpath set properly.
+  def self.run(command, pdfs, opts, return_output=false)
+    pdfs    = [pdfs].flatten.map{|pdf| "\"#{pdf}\""}.join(' ')
+    args    = parse_options(opts)
+    cmd     = "java #{HEADLESS} #{LOGGING} -cp #{CLASSPATH} #{command} #{args} #{pdfs} 2>&1"
+    result  = `#{cmd}`.chomp
+    raise ExtractionFailed, result if $? != 0
+    return return_output ? (result.empty? ? nil : result) : true
+  end
+
+end
+
+require 'tmpdir'
+require 'fileutils'
+require "#{Docsplit::ROOT}/lib/docsplit/image_extractor"
+require "#{Docsplit::ROOT}/lib/docsplit/argument_parser"
+require "#{Docsplit::ROOT}/lib/docsplit/transparent_pdfs"

data/vendor/logging.properties

@@ -0,0 +1 @@
+.level=WARNING

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: docsplit
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jeremy Ashkenas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-07 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: "    Docsplit is a command-line utility and Ruby library for splitting apart\n    documents into their component parts: searchable UTF-8 plain text, page\n    images or thumbnails in any format, PDFs, single pages, and document\n    metadata (title, author, number of pages...)\n"
+email: jeremy@documentcloud.org
+executables: 
+- docsplit
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- build/org/documentcloud/ExtractInfo$1.class
+- build/org/documentcloud/ExtractInfo$Keys.class
+- build/org/documentcloud/ExtractInfo.class
+- build/org/documentcloud/Extractor.class
+- build/org/documentcloud/ExtractPages.class
+- build/org/documentcloud/ExtractText.class
+- lib/docsplit/argument_parser.rb
+- lib/docsplit/command_line.rb
+- lib/docsplit/ExtractInfo.java
+- lib/docsplit/Extractor.java
+- lib/docsplit/ExtractPages.java
+- lib/docsplit/ExtractText.java
+- lib/docsplit/image_extractor.rb
+- lib/docsplit/transparent_pdfs.rb
+- lib/docsplit.rb
+- bin/docsplit
+- vendor/bcmail.jar
+- vendor/bcprov.jar
+- vendor/commons-logging.jar
+- vendor/fontbox.jar
+- vendor/jodconverter/commons-cli-1.2.jar
+- vendor/jodconverter/commons-io-1.4.jar
+- vendor/jodconverter/jodconverter-2.2.2.jar
+- vendor/jodconverter/jodconverter-cli-2.2.2.jar
+- vendor/jodconverter/juh-3.0.1.jar
+- vendor/jodconverter/jurt-3.0.1.jar
+- vendor/jodconverter/ridl-3.0.1.jar
+- vendor/jodconverter/slf4j-api-1.5.6.jar
+- vendor/jodconverter/slf4j-jdk14-1.5.6.jar
+- vendor/jodconverter/unoil-3.0.1.jar
+- vendor/logging.properties
+- vendor/pdfbox.jar
+- docsplit.gemspec
+- LICENSE
+- README
+has_rdoc: false
+homepage: http://documentcloud.github.com/docsplit/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: docsplit
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Break Apart Documents into Images, Text, Pages and PDFs
+test_files: []
+