pdfshaver 0.0.1.alpha

data/ext/pdfium_ruby/page.h

@@ -0,0 +1,36 @@
+#ifndef __PAGE_H__
+#define __PAGE_H__
+
+// forward declaration since Page/Document classes are interdependent
+class Document;
+#include "pdfium_ruby.h"
+#include "document.h"
+
+class Page {
+  public:
+    Page();
+    
+    bool load(Document* document, int page_number);
+    
+    double width();
+    double height();
+    double aspect();
+    
+    bool render(char* path, int width, int height);
+    
+    ~Page();
+    
+  private:
+    int page_index;
+    bool opened;
+    Document *document;
+    FPDF_PAGE fpdf_page;
+};
+
+void Define_Page();
+VALUE initialize_page_internals(int arg_count, VALUE* args, VALUE self);
+VALUE page_render(int arg_count, VALUE* args, VALUE self);
+VALUE page_allocate(VALUE rb_PDFShaver_Page);
+static void destroy_page(Page* page);
+
+#endif

data/ext/pdfium_ruby/pdfium_ruby.cpp

@@ -0,0 +1,17 @@
+#include "pdfium_ruby.h"
+
+#include "fpdfview.h"
+
+extern "C"
+void Init_pdfium_ruby (void) {
+  // Initialize PDFium
+  FPDF_InitLibrary();
+  
+  // Define `PDFShaver` module as a namespace for all of our other objects
+  VALUE rb_PDFShaver = rb_define_module("PDFShaver");
+  
+  // Define `Document` and `Page` classes
+  Define_Document();
+  Define_Page();
+  //Define_PageSet();
+}

data/ext/pdfium_ruby/pdfium_ruby.h

@@ -0,0 +1,20 @@
+#ifndef __PDFIUM_RUBY_H__
+#define __PDFIUM_RUBY_H__
+
+extern "C" {
+  #include "ruby.h"
+}
+
+// Inspired by https://github.com/jasonroelofs/rice/blob/1740a6d12c99fce8c21eda3c5385738318ab9172/rice/detail/ruby.hpp#L33-L37
+// Casts C functions into a type that C++ is happy calling
+extern "C" typedef VALUE (*CPP_RUBY_METHOD_FUNC)(ANYARGS);
+
+void Define_Document();
+void Define_Page();
+void Define_PageSet();
+
+// helper function for printing string literals for debugging purposes
+void inline ruby_puts_cstring(const char* str) { rb_funcall(rb_cObject, rb_intern("puts"), 1, rb_str_new_cstr(str)); }
+void inline ruby_puts_values(VALUE str){ rb_funcall(rb_cObject, rb_intern("puts"), 1, str); }
+
+#endif

data/lib/pdfshaver.rb

@@ -0,0 +1,13 @@
+module PDFShaver
+  class EncryptionError < StandardError; end
+  class InvalidFormatError < StandardError; end
+  class MissingHandlerError < StandardError; end
+end
+
+%w[
+  document
+  page
+  page_set
+  version
+].each { |file| require_relative File.join('pdfshaver', file) }
+require_relative 'pdfium_ruby'

data/lib/pdfshaver/document.rb

@@ -0,0 +1,21 @@
+module PDFShaver
+  class Document
+    attr_reader :length, :path
+    
+    def initialize path, options={}
+      raise ArgumentError, "Can't find a file at '#{path}' to open" unless File.exists? path
+      # otherwise attempt to acquire it.
+      
+      @path = path
+      open_document_with_pdfium(path)
+    end
+    
+    def == other
+      File.realpath(self.path) == File.realpath(other.path)
+    end
+    
+    def pages(page_list=:all)
+      PageSet.new(self, page_list)
+    end
+  end
+end

data/lib/pdfshaver/page.rb

@@ -0,0 +1,117 @@
+module PDFShaver
+  class Page
+    GM_MATCHER = /^\s*((?<width>\d+)x((?<height>\d+))?|x?(?<height>\d+))(?<modifier>[@%!<>^]+)?\s*$/
+    attr_reader :document, :width, :height, :aspect, :number, :index
+    
+    def initialize document, number, options={}
+      raise ArgumentError unless document.kind_of? PDFShaver::Document
+      raise ArgumentError unless number.kind_of? Integer
+      raise ArgumentError unless number > 0 and number <= document.length
+      
+      @number   = number
+      @index    = number - 1
+      @document = document
+      initialize_page_internals document, @index
+    end
+    
+    def == other
+      raise ArgumentError, "unable to compare #{self.class} with #{other.class}" unless other.kind_of? self.class
+      (self.document == other.document) and (self.index == other.index)
+    end
+    
+    def <=> other
+      raise ArgumentError, "unable to compare #{self.class} with #{other.class}" unless other.kind_of? self.class
+      self.index <=> other.index
+    end
+    
+    def extract_dimensions_from_gm_geometry_string(arg)
+      dimensions = {}
+      arg.match(GM_MATCHER) do |match|
+        
+        # grab parsed tokens
+        requested_width  = match[:width].to_f unless match[:width].nil? 
+        requested_height = match[:height].to_f unless match[:height].nil? 
+        modifier         = match[:modifier] || ""
+        
+        ## Algorithm ported from GraphicsMagick's GetMagickGeometry function.
+        #
+        # the '@' option precludes all other options.
+        if modifier.include? '@'
+          # calculate the current page area
+          # and the specified target area for comparison
+          current_area = self.width * self.height
+          target_area  = (requested_width || 1) * (requested_height || 1)
+          
+          resize = if modifier.include? '>'
+            current_area > target_area
+          elsif modifier.include? '<'
+            current_area < target_area
+          else
+            true
+          end
+          
+          if resize
+            scale = 1.0 / Math.sqrt(current_area/target_area)
+            dimensions[:width]  = (self.width*scale+0.25).floor
+            dimensions[:height] = (self.height*scale+0.25).floor
+          end
+        else # Handle all of the non area modes.
+          width = requested_width
+          height = requested_height
+          
+          # when supplied with only a width or a height
+          # infer the other using the page's aspect ratio.
+          if width and not height
+            height = (width/self.aspect+0.5).floor
+          elsif height and not width
+            width  = (self.width.to_f/self.height*height+0.5).floor
+          end
+          
+          # If proportional mode is requested
+          # 
+          if modifier.include? '%'
+            x_scale = width
+            y_scale = height
+            x_scale = y_scale if requested_width.nil? or requested_height.nil?
+            width   = ((self.width * x_scale / 100.0) +0.5).floor
+            height  = ((self.height * y_scale / 100.0) +0.5).floor
+            # this is to match how GraphicsMagick works.
+            requested_width = width
+            requested_height = height
+          end
+          
+          if modifier.include? '!' and ((width != requested_width) || (height != requested_height))
+            if (requested_width == 0) || (requested_height == 0)
+              scale = 1.0
+            else
+              width_ratio  = width / self.width
+              height_ratio = height / self.height
+              scale = width_ratio
+            end
+            
+            width  = (scale*self.width+0.5).floor
+            height = (scale*self.height+0.5).floor
+          end
+          
+          if modifier.include? '>'
+            width  = self.width  if self.width  < width
+            height = self.height if self.height < height
+          end
+          
+          if modifier.include? '<'
+            width  = self.width  if self.width  > width
+            height = self.height if self.height > height
+          end
+          
+          dimensions[:width]  = width.floor
+          dimensions[:height] = height.floor
+        end
+        dimensions[:width]  ||= self.width.floor
+        dimensions[:height] ||= self.height.floor
+        return dimensions
+      end
+      
+      raise ArgumentError, "unable to extract width & height from '#{arg}'"
+    end
+  end
+end

data/lib/pdfshaver/page_set.rb

@@ -0,0 +1,83 @@
+module PDFShaver
+  class PageSet
+    include Enumerable
+
+    attr_reader :document
+    def initialize document, page_list=:all, options={}
+      @document = document
+      @page_list = extract_page_numbers(page_list)
+    end
+    
+    def each(&block)
+      enumerator.each(&block)
+    end
+    
+    def [](page_index)
+      Page.new(@document, @page_list.to_a[page_index])
+    end
+    
+    def first
+      Page.new(@document, @page_list.first)
+    end
+    
+    def last
+      Page.new(@document, @page_list.last)
+    end
+    
+    def size
+      @page_list.size
+    end
+    
+    private
+    def enumerator
+      Enumerator.new do |yielder|
+        @page_list.each do |page_number|
+          yielder.yield Page.new(self.document, page_number)
+        end
+      end
+    end
+    
+    def extract_page_numbers(inputs)
+      case inputs
+      when :all
+        Range.new(1,self.document.length)
+      when Numeric
+        raise ArgumentError, "#{inputs} is not a valid page number" unless valid_page_number?(inputs)
+        [inputs]
+      when Range
+        unless valid_page_range?(inputs)
+          raise ArgumentError, "#{inputs} did not fall in a valid range of pages (#{1..self.document.length})"
+        end
+        inputs
+      when Array
+        numbers = []
+        inputs.flatten.each do |input|
+          case
+          when valid_page_number?(input) then numbers.push input
+          when valid_page_range?(input)  then numbers += input.to_a
+          when valid_page_string?(input) then 
+          else raise ArgumentError, "#{input} is not a valid page or list of pages (as part of #{inputs})"
+          end
+        end
+        numbers.sort
+      when String
+        valid_page_string?(inputs)
+      else 
+        raise ArgumentError, "#{inputs.inspect} is not a valid list of pages"
+      end
+    end
+    
+    def valid_page_number?(number)
+      number.kind_of?(Numeric) and number > 0 and number <= self.document.length
+    end
+    
+    def valid_page_range?(range)
+      range.kind_of?(Range) and range.first <= range.last and
+      valid_page_number?(range.first) and valid_page_number?(range.last)
+    end
+    
+    def valid_page_string?(input)
+      raise ArgumentError, "todo: support strings as page specifiers"
+    end
+  end
+end

data/lib/pdfshaver/version.rb

@@ -0,0 +1,3 @@
+module PDFShaver
+  VERSION='0.0.1'
+end

data/pdfshaver.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pdfshaver/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'pdfshaver'
+  s.version     = PDFShaver::VERSION + ".alpha"
+  s.licenses    = ['MIT']
+  s.summary     = "Shave pages off of PDFs as images"
+  s.authors     = ["Ted Han", "Nathan Stitt"]
+  s.email       = 'opensource@documentcloud.org'
+  s.extensions = 'ext/pdfium_ruby/extconf.rb'
+  s.files       = Dir.glob %w[
+    lib/pdfshaver.rb
+    lib/*/**/*
+    ext/**/*
+    test/**/*
+    Gemfile
+    pdfshaver.gemspec
+    Rakefile
+    Readme.md
+  ]
+  
+  s.add_development_dependency "bundler", "~> 1.5"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake-compiler'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'fastimage'
+end

data/test/document_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'spec_helper'))
+
+describe PDFShaver::Document do
+  
+  it "should be instantiated" do
+    path = File.join(FIXTURES, 'uncharter.pdf')
+    PDFShaver::Document.new(path).must_be_instance_of PDFShaver::Document
+  end
+  
+  it "should throw an error if path can't be found" do
+    Proc.new{ PDFShaver::Document.new("suede shoes") }.must_raise ArgumentError
+  end
+  
+  it "should throw an error if a document can't be opened" do
+    Proc.new do
+      path = File.join(FIXTURES, 'completely_encrypted.pdf')
+      PDFShaver::Document.new(path)
+    end.must_raise ArgumentError
+  end
+  
+  describe "instance methods" do
+    before do
+      @path = File.join(FIXTURES, 'uncharter.pdf')
+      @document = PDFShaver::Document.new(@path)
+    end
+    
+    it "should have a length" do
+      @document.length.must_equal 55
+    end
+    
+    it { @document.must_equal @document }
+    it { @document.must_equal PDFShaver::Document.new(@path) }
+    it { @document.wont_equal PDFShaver::Document.new(File.join(FIXTURES, 'letter-to-canadians-from-jack-layton.pdf')) }
+  end
+  
+end

data/test/gm_compatability_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'spec_helper'))
+
+describe "Resize arguments" do
+  before do
+    path = File.join(FIXTURES, 'uncharter.pdf')
+    @document = PDFShaver::Document.new(path)
+    @page = PDFShaver::Page.new(@document, 1)
+  end
+
+  describe "Syntax" do
+    class TokenSet
+      # Create a list of attributes which we can
+      # refer back to later
+      # and use the splat operator to define our attributes
+      KEYS = [:width, :height, :modifier]
+      attr_reader *KEYS
+
+      # helper methods so we can pretend an instance is a hash
+      def [](key); self.send(key); end
+      def []=(key, val); self.instance_variable_set("@#{key}", val); end
+
+      # use the KEYS and their order to initialize instance variables
+      def initialize(*attributes)
+        KEYS.each_with_index{ |key, index| self[key] = attributes[index] }
+      end
+    end
+  
+    it "should match valid graphicsmagick strings" do
+      inputs = {
+        "100"      => TokenSet.new(nil,   "100", nil),
+        "101x102"  => TokenSet.new("101", "102", nil),
+        "103x"     => TokenSet.new("103", nil,   nil),
+        "x104"     => TokenSet.new(nil,   "104", nil),
+        "105%"     => TokenSet.new(nil,   "105", "%"), 
+        "106@"     => TokenSet.new(nil,   "106", "@"), 
+        "107<"     => TokenSet.new(nil,   "107", "<"), 
+        "108>"     => TokenSet.new(nil,   "108", ">"),
+        "109x110%" => TokenSet.new("109", "110", "%"),
+        "x111%"    => TokenSet.new(nil,   "111", "%"),
+        "112x%"    => TokenSet.new("112", nil,   "%"),
+      }
+    
+      inputs.each do |input, expected|
+        input.must_match(PDFShaver::Page::GM_MATCHER)
+        match = input.match(PDFShaver::Page::GM_MATCHER)
+        TokenSet::KEYS.each{ |key| match[key].must_equal expected[key] }
+      end
+    end
+  end
+
+  describe "Semantic" do
+    class Size
+      attr_reader :width, :height, :aspect
+      def initialize(width, height)
+        @width = width
+        @height = height
+        @aspect = @width.to_f / height
+      end
+
+      def scale(factor)
+        self.class.new((@width*factor).to_i, (@height*factor).to_i)
+      end
+    end
+  
+    it "should specify width and height" do
+      w = @page.width.to_i
+      h = @page.height.to_i
+      base = Size.new(w,h)
+      {
+        "#{w}x#{h}"        => base,
+        "#{(w*0.5).to_i}x" => base.scale(0.5),
+        "x#{h*2}"          => base.scale(2),
+        "100x100!"         => Size.new(100, 100),
+        "100x100%"         => base,
+        "200x200%"         => base.scale(2),
+        "200x200@"         => Size.new(176, 227),
+        "1000>"            => base,
+        #"1000<"            => Size.new(773, 1000),
+        "500>"             => Size.new(386, 500),
+        "500x>"            => Size.new(500, 647)
+      }.each do |input, expected|
+        #puts "#{input} : #{expected.inspect}"
+        output = @page.extract_dimensions_from_gm_geometry_string(input)
+        #puts "#{output.inspect} vs #{expected.inspect}"
+        dimensions = Size.new(output[:width], output[:height])
+        dimensions.aspect.must_be_within_delta expected.aspect, 0.005
+        dimensions.width.must_be_within_delta expected.width, 1
+        dimensions.height.must_be_within_delta expected.height, 1
+      end
+    end
+  end
+end