dragonfly_pdf 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39808b6176e5805a9bc82d359f9d427bc42e476c
+  data.tar.gz: 60b458c14a7531d7a457f274b58ad4ce67a48ab8
+SHA512:
+  metadata.gz: beee74901265a5e8f0c674f82d328140b5794385adb0f7d93514afc328df34a64e62210a86913ed3966c4fa0752e5e882c6b98c235e4b37ea371489516abac25
+  data.tar.gz: 88c5d02b9e3eea8c8a59d128b8e3b0381197abbb28b9102712bcfb91cdde6094373f77291160e11706546de3a8cfe256fa5e1474e94a048734dfa4f4d8611db5

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+dragonfly.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dragonfly_pdf.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  watch(%r{^lib/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/.+_test\.rb$})
+  watch(%r{^test/test_helper\.rb$})                       { 'test' }
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Tomas Celizna
+
+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.md

@@ -0,0 +1,88 @@
+# Dragonfly PDF
+
+[![Build Status](https://travis-ci.org/tomasc/dragonfly_pdf.svg)](https://travis-ci.org/tomasc/dragonfly_pdf) [![Gem Version](https://badge.fury.io/rb/dragonfly_pdf.svg)](http://badge.fury.io/rb/dragonfly_pdf) [![Coverage Status](https://img.shields.io/coveralls/tomasc/dragonfly_pdf.svg)](https://coveralls.io/r/tomasc/dragonfly_pdf)
+
+[Dragonfly](https://github.com/markevans/dragonfly) PDF analysers and processors.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dragonfly_pdf'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dragonfly_pdf
+
+## Plugin
+The analyser and processors are added by configuring the plugin
+
+```ruby
+Dragonfly.app.configure do
+  plugin :pdf
+end
+```
+
+## Analysers
+
+### PDF properties
+
+This processor has argument `spreads` (by default set to `false`). When `true`, the analyser assumes the PDF might contain 2 real pages per one PDF page (as when saving with the spreads option in InDesign) and recalculates the PDF properties accordingly (including situations when PDF starts or ends with single page).
+
+```ruby
+pdf.pdf_properties(spreads=false)
+```
+
+Returns Hash of PDF properties:
+
+```ruby
+{
+    page_count: 4,
+    spread_count: 3,
+    page_numbers: [[1], [2, 3], [4]],
+    widths: [[210.0], [210.0, 210.0], [210.0]],
+    heights: [[297.0], [297.0, 297.0], [297.0]],
+    aspect_ratios: [[0.71], [0.71, 0.71], [0.71]], 
+    info: { … }
+}
+```
+
+When the `spreads` argument is set to true, all page arrays (page_numbers, widths, heights, aspect_ratios) are two dimensional (as illustrated above), representing spreads and nested individual pages.
+
+## Processors
+
+### Page Thumb
+
+Generates thumbnail of a specified page, in defined density (dpi) and format.
+
+```ruby
+pdf.page_thumb(page_number=0, opts={})
+```
+
+The available options and their default values are:
+
+```ruby
+{
+    density: 600,
+    format: :png,
+    spreads: false
+}
+```
+
+Similarly to the `#pdf_properties`, the `#page_thumb` processor takes into account the `spreads` option.
+
+## TODO
+
+* Add more tests for `#page_thumb`
+
+## Contributing
+
+1. Fork it ( https://github.com/tomasc/dragonfly_pdf/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task default: :test

data/dragonfly_pdf.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dragonfly_pdf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dragonfly_pdf"
+  spec.version       = DragonflyPdf::VERSION
+  spec.authors       = ["Tomas Celizna"]
+  spec.email         = ["tomas.celizna@gmail.com"]
+  spec.summary       = %q{Dragonfly PDF analysers and processors.}
+  spec.description   = %q{Dragonfly PDF analysers and processors.}
+  spec.homepage      = "https://github.com/tomasc/dragonfly_pdf"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "dragonfly", "~> 1.0"
+  spec.add_dependency "pdf-reader", "~> 1.3"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency "minitest"
+end

data/lib/dragonfly_pdf/analysers/pdf_properties.rb

@@ -0,0 +1,148 @@
+require 'pdf-reader'
+
+module DragonflyPdf
+  module Analysers
+    class PdfProperties
+
+      def call content, spreads=false
+        pdf = PDF::Reader.new(content.file)
+
+        {
+          page_count: page_count(pdf, spreads),
+          spread_count: spread_count(pdf, spreads),
+          page_numbers: page_numbers(pdf, spreads),
+          widths: widths(pdf, spreads),
+          heights: heights(pdf, spreads),
+          aspect_ratios: aspect_ratios(pdf, spreads),
+          info: pdf.info
+        }
+      end
+
+      private # =============================================================
+
+      def widths pdf, spreads
+        pdf_page_widths = pdf.pages.map do |page|
+          media_box = page.attributes[:MediaBox]
+          pt2mm(media_box[2] - media_box[0]).round(2)
+        end
+
+        return pdf_page_widths unless spreads
+
+        res = []
+        i = 0
+        spread = []
+        page_numbers(pdf, spreads).each do |s|
+          if s.count == 1
+            spread << pdf_page_widths[i]
+          else
+            spread << pdf_page_widths[i]/2
+            spread << pdf_page_widths[i]/2
+          end
+          res << spread
+          spread = []
+          i = i+1
+        end
+        res
+      end
+
+      # ---------------------------------------------------------------------
+        
+      def heights pdf, spreads
+        pdf_page_heights = pdf.pages.map do |page|
+          media_box = page.attributes[:MediaBox]
+          pt2mm(media_box[3] - media_box[1]).round(2)
+        end
+
+        return pdf_page_heights unless spreads
+
+        res = []
+        i = 0
+        spread = []
+        page_numbers(pdf, spreads).each do |s|
+          if s.count == 1
+            spread << pdf_page_heights[i]
+          else
+            spread << pdf_page_heights[i]
+            spread << pdf_page_heights[i]
+          end
+          res << spread
+          spread = []
+          i = i+1
+        end
+        res
+      end
+
+      # ---------------------------------------------------------------------
+        
+      def aspect_ratios pdf, spreads
+        pdf_aspect_ratios = widths(pdf, false).zip(heights(pdf, false)).map do |width, height|
+          (width / height)
+        end
+
+        return pdf_aspect_ratios unless spreads
+
+        res = []
+        i = 0
+        spread = []
+        page_numbers(pdf, spreads).each do |s|
+          if s.count == 1
+            spread << pdf_aspect_ratios[i]
+          else
+            spread << pdf_aspect_ratios[i]/2
+            spread << pdf_aspect_ratios[i]/2
+          end
+          res << spread
+          spread = []
+          i = i+1
+        end
+        res
+      end
+
+      # ---------------------------------------------------------------------
+        
+      def page_numbers pdf, spreads
+        return pdf.pages.collect { |p| p.number } unless spreads
+
+        page_widths = widths(pdf, false)
+        single_page_width = page_widths.uniq.count == 1 ? -9999999 : widths(pdf, false).min
+
+        i = 1
+        res = []
+        spread = []
+
+        page_widths.each do |page_width|
+          if page_width > single_page_width
+            spread << i
+            i = i+1
+            spread << i
+          else
+            spread << i
+          end
+          res << spread
+          spread = []
+          i = i+1
+        end
+
+        res
+      end
+
+      # ---------------------------------------------------------------------
+      
+      def page_count pdf, spreads
+        page_numbers(pdf, spreads).flatten.count
+      end
+
+      def spread_count pdf, spreads
+        return 0 unless spreads
+        page_numbers(pdf, spreads).count
+      end
+
+      # =====================================================================
+      
+      def pt2mm pt
+        (pt / 72.0) * 25.4
+      end
+
+    end
+  end
+end

data/lib/dragonfly_pdf/plugin.rb

@@ -0,0 +1,46 @@
+require 'dragonfly_pdf/analysers/pdf_properties'
+require 'dragonfly_pdf/processors/page_thumb'
+
+module DragonflyPdf
+  class Plugin
+
+    def call app, opts={}
+      app.add_analyser :pdf_properties, DragonflyPdf::Analysers::PdfProperties.new
+
+      app.add_analyser :page_count do |content|
+        content.analyse(:pdf_properties)[:page_count]
+      end
+
+      app.add_analyser :spread_count do |content|
+        content.analyse(:pdf_properties)[:spread_count]
+      end
+
+      app.add_analyser :page_numbers do |content|
+        content.analyse(:pdf_properties)[:page_numbers]
+      end
+
+      app.add_analyser :widths do |content|
+        content.analyse(:pdf_properties)[:widths]
+      end
+      
+      app.add_analyser :heights do |content|
+        content.analyse(:pdf_properties)[:heights]
+      end
+      
+      app.add_analyser :aspect_ratios do |content|
+        attrs = content.analyse(:pdf_properties)[:aspect_ratios]
+      end
+
+      app.add_analyser :info do |content|
+        attrs = content.analyse(:pdf_properties)[:info]
+      end
+      
+      # ---------------------------------------------------------------------
+      
+      app.add_processor :page_thumb, DragonflyPdf::Processors::PageThumb.new
+    end
+
+  end
+end
+
+Dragonfly::App.register_plugin(:pdf) { DragonflyPdf::Plugin.new }

data/lib/dragonfly_pdf/processors/page_thumb.rb

@@ -0,0 +1,62 @@
+require_relative '../analysers/pdf_properties'
+
+module DragonflyPdf
+  module Processors
+    class PageThumb
+
+      class UnsupportedFormat < RuntimeError; end
+
+      def call content, page_number=0, opts={}
+        format = opts.fetch(:format, :png)
+        # raise UnsupportedFormat unless %w(tif jpg jpeg png gif).include?(format.to_s)
+
+        density = opts.fetch(:density, 600)
+        spreads = opts.fetch(:spreads, false)
+
+        args = "-alpha deactivate -background white -colorspace sRGB -density #{density}x#{density} -define pdf:use-cropbox=true -define pdf:use-trimbox=true"
+        crop_args = ''
+
+        pdf_properties = DragonflyPdf::Analysers::PdfProperties.new.call(content, spreads)
+
+        if spreads
+          spread = pdf_properties[:page_numbers].detect{ |s| s.include?(page_number) }
+          spread_number = pdf_properties[:page_numbers].index(spread)
+          spread_side = spread.index(page_number)
+          page_to_delete = 1-spread_side
+
+          pdf_page_number = spread_number
+          crop_args = "-crop 50%x100% -delete #{page_to_delete}"
+        else
+          pdf_page_number = page_number
+        end
+
+        content.shell_update(ext: format) do |old_path, new_path|
+          "#{convert_command} #{args} #{crop_args} #{old_path}[#{pdf_page_number}] #{new_path}"
+        end
+
+        content.meta['format'] = format.to_s
+        content.ext = format
+      end
+   
+      def update_url attrs, args='', opts={}
+        format = opts['format']
+        attrs.ext = format if format
+      end
+
+      private # =============================================================
+
+      def convert_command
+        'convert'
+      end
+
+      def pdf_page_number page_number, spreads
+        return 1
+      end
+
+      def pdf_crop_args page_number, spreads
+        return
+      end
+
+    end
+  end
+end

data/lib/dragonfly_pdf/version.rb

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

data/lib/dragonfly_pdf.rb

@@ -0,0 +1,3 @@
+require "dragonfly_pdf/plugin"
+
+require "dragonfly_pdf/version"

data/test/dragonfly_pdf/analysers/pdf_properties_test.rb

@@ -0,0 +1,238 @@
+require 'test_helper'
+
+module DragonflyPdf
+  module Analysers
+    describe PdfProperties do
+
+      let(:app) { test_app.configure_with(:pdf) }
+      let(:analyser) { DragonflyPdf::Analysers::PdfProperties.new }
+
+      let(:single_pages) { app.fetch_file(SAMPLES_DIR.join('sample_pages.pdf')) }
+      let(:spreads) { app.fetch_file(SAMPLES_DIR.join('sample_spreads.pdf')) }
+      let(:spreads_back) { app.fetch_file(SAMPLES_DIR.join('sample_spreads_back.pdf')) }
+      let(:spreads_cover) { app.fetch_file(SAMPLES_DIR.join('sample_spreads_cover.pdf')) }
+      let(:spreads_cover_back) { app.fetch_file(SAMPLES_DIR.join('sample_spreads_cover_back.pdf')) }
+
+      describe 'call' do
+        let(:pdf_properties) { analyser.call(single_pages) }
+
+        it 'returns Hash' do
+          pdf_properties.must_be_kind_of Hash
+        end
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe '#page_numbers' do
+        describe 'for single page PDF' do
+          it 'returns one-dimensional array' do
+            analyser.call(single_pages)[:page_numbers].must_equal [1,2,3,4,5,6,7,8,9,10]
+          end
+        end
+
+        describe 'for PDF with spreads' do
+          it 'returns two-dimensional array' do
+            analyser.call(spreads, true)[:page_numbers].must_equal [[1,2],[3,4],[5,6],[7,8]]
+          end
+        end
+
+        describe 'for PDF with spreads and a cover' do
+          it 'returns two-dimensional array' do
+            analyser.call(spreads_cover, true)[:page_numbers].must_equal [[1],[2,3],[4,5],[6,7],[8,9]]
+          end
+        end
+
+        describe 'for PDF with spreads and a back cover' do
+          it 'returns two-dimensional array' do
+            analyser.call(spreads_back, true)[:page_numbers].must_equal [[1,2],[3,4],[5,6],[7,8],[9]]
+          end
+        end
+
+        describe 'for PDF with spreads and a front and a back cover' do
+          it 'returns two-dimensional array' do
+            analyser.call(spreads_cover_back, true)[:page_numbers].must_equal [[1],[2,3],[4,5],[6,7],[8,9],[10]]
+          end
+        end
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe '#page_count' do
+        describe 'for single page PDF' do
+          it 'returns correct page count' do
+            analyser.call(single_pages)[:page_count].must_equal 10
+          end
+        end
+
+        describe 'for PDF with spreads' do
+          it 'returns correct page count' do
+            analyser.call(spreads, true)[:page_count].must_equal 8
+          end
+        end
+
+        describe 'for PDF with spreads and a cover' do
+          it 'returns correct page count' do
+            analyser.call(spreads_cover, true)[:page_count].must_equal 9
+          end
+        end
+
+        describe 'for PDF with spreads and a back cover' do
+          it 'returns correct page count' do
+            analyser.call(spreads_back, true)[:page_count].must_equal 9
+          end
+        end
+
+        describe 'for PDF with spreads and a front and a back cover' do
+          it 'returns correct page count' do
+            analyser.call(spreads_cover_back, true)[:page_count].must_equal 10
+          end
+        end
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe '#spread_count' do
+        describe 'for single page PDF' do
+          it 'returns correct page count' do
+            analyser.call(single_pages)[:spread_count].must_equal 0
+          end
+        end
+
+        describe 'for PDF with spreads' do
+          it 'returns correct page count' do
+            analyser.call(spreads, true)[:spread_count].must_equal 4
+          end
+        end
+
+        describe 'for PDF with spreads and a cover' do
+          it 'returns correct page count' do
+            analyser.call(spreads_cover, true)[:spread_count].must_equal 5
+          end
+        end
+
+        describe 'for PDF with spreads and a back cover' do
+          it 'returns correct page count' do
+            analyser.call(spreads_back, true)[:spread_count].must_equal 5
+          end
+        end
+
+        describe 'for PDF with spreads and a front and a back cover' do
+          it 'returns correct page count' do
+            analyser.call(spreads_cover_back, true)[:spread_count].must_equal 6
+          end
+        end
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe '#widths' do
+        describe 'for single page PDF' do
+          it 'returns widths' do
+            analyser.call(single_pages)[:widths].must_equal [210.0, 210.0, 210.0, 210.0, 210.0, 210.0, 210.0, 210.0, 210.0, 210.0]
+          end
+        end
+
+        describe 'for PDF with spreads' do
+          it 'returns widths' do
+            analyser.call(spreads, true)[:widths].must_equal [[210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0]]
+          end
+        end
+
+        describe 'for PDF with spreads and a cover' do
+          it 'returns correct widths' do
+            analyser.call(spreads_cover, true)[:widths].must_equal [[210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0]]
+          end
+        end
+
+        describe 'for PDF with spreads and a back cover' do
+          it 'returns correct widths' do
+            analyser.call(spreads_back, true)[:widths].must_equal [[210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0]]
+          end
+        end
+
+        describe 'for PDF with spreads and a front and a back cover' do
+          it 'returns correct widths' do
+            analyser.call(spreads_cover_back, true)[:widths].must_equal [[210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0]]
+          end
+        end
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe '#heights' do
+        describe 'for single page PDF' do
+          it 'returns heights' do
+            analyser.call(single_pages)[:heights].must_equal [297.0, 297.0, 297.0, 297.0, 297.0, 297.0, 297.0, 297.0, 297.0, 297.0]
+          end
+        end
+
+        describe 'for PDF with spreads' do
+          it 'returns heights' do
+            analyser.call(spreads, true)[:heights].must_equal [[297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0]]
+          end
+        end
+
+        describe 'for PDF with spreads and a cover' do
+          it 'returns correct heights' do
+            analyser.call(spreads_cover, true)[:heights].must_equal [[297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0]]
+          end
+        end
+
+        describe 'for PDF with spreads and a back cover' do
+          it 'returns correct heights' do
+            analyser.call(spreads_back, true)[:heights].must_equal [[297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0]]
+          end
+        end
+
+        describe 'for PDF with spreads and a front and a back cover' do
+          it 'returns correct heights' do
+            analyser.call(spreads_cover_back, true)[:heights].must_equal [[297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0]]
+          end
+        end
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe '#aspect_ratios' do
+        describe 'for single page PDF' do
+          it 'returns aspect ratios' do
+            analyser.call(single_pages)[:aspect_ratios].map{ |i| i.round(2) }.must_equal [0.71, 0.71, 0.71, 0.71, 0.71, 0.71, 0.71, 0.71, 0.71, 0.71]
+          end
+        end
+
+        describe 'for PDF with spreads' do
+          it 'returns aspect ratios' do
+            analyser.call(spreads, true)[:aspect_ratios].map{ |i| i.is_a?(Array) ? i.map{ |j| j.round(2) } : i.round(2) }.must_equal [[0.71, 0.71], [0.71, 0.71], [0.71, 0.71], [0.71, 0.71]]
+          end
+        end
+
+        describe 'for PDF with spreads and a cover' do
+          it 'returns correct aspect ratios' do
+            analyser.call(spreads_cover, true)[:aspect_ratios].map{ |i| i.is_a?(Array) ? i.map{ |j| j.round(2) } : i.round(2) }.must_equal [[0.71], [0.71, 0.71], [0.71, 0.71], [0.71, 0.71], [0.71, 0.71]]
+          end
+        end
+
+        describe 'for PDF with spreads and a back cover' do
+          it 'returns correct aspect ratios' do
+            analyser.call(spreads_back, true)[:aspect_ratios].map{ |i| i.is_a?(Array) ? i.map{ |j| j.round(2) } : i.round(2) }.must_equal [[0.71, 0.71], [0.71, 0.71], [0.71, 0.71], [0.71, 0.71], [0.71]]
+          end
+        end
+
+        describe 'for PDF with spreads and a front and a back cover' do
+          it 'returns correct aspect ratios' do
+            analyser.call(spreads_cover_back, true)[:aspect_ratios].map{ |i| i.is_a?(Array) ? i.map{ |j| j.round(2) } : i.round(2) }.must_equal [[0.71], [0.71, 0.71], [0.71, 0.71], [0.71, 0.71], [0.71, 0.71], [0.71]]
+          end
+        end
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe '#info' do
+        it 'returns Hash' do
+          analyser.call(single_pages)[:info].must_be_kind_of Hash
+        end
+      end
+
+    end
+  end
+end

data/test/dragonfly_pdf/plugin_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module DragonflyPdf
+  describe Plugin do
+
+    let(:app) { test_app.configure_with(:pdf) }
+    let(:pdf) { app.fetch_file(SAMPLES_DIR.join('sample_pages.pdf')) }
+
+    # ---------------------------------------------------------------------
+
+    describe 'analysers' do
+      it 'adds #page_count' do
+        pdf.must_respond_to :page_count
+      end
+      it 'adds #spread_count' do
+        pdf.must_respond_to :spread_count
+      end
+      it 'adds #page_numbers' do
+        pdf.must_respond_to :page_numbers
+      end
+      it 'adds #widths' do
+        pdf.must_respond_to :widths
+      end
+      it 'adds #heights' do
+        pdf.must_respond_to :heights
+      end
+      it 'adds #aspect_ratios' do
+        pdf.must_respond_to :aspect_ratios
+      end
+      it 'adds #info' do
+        pdf.must_respond_to :info
+      end
+    end
+
+  end
+end

data/test/dragonfly_pdf/processors/page_thumb_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+require 'pdf-reader'
+
+module DragonflyPdf
+  module Processors
+    describe PageThumb do
+
+      let(:app) { test_app.configure_with(:pdf) }
+      let(:processor) { DragonflyPdf::Processors::PageThumb.new }
+
+      let(:single_pages) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_pages.pdf')) }
+      let(:spreads) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_spreads.pdf')) }
+      let(:spreads_back) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_spreads_back.pdf')) }
+      let(:spreads_cover) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_spreads_cover.pdf')) }
+      let(:spreads_cover_back) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_spreads_cover_back.pdf')) }
+
+      it 'returns PNG by default' do
+        processor.call(single_pages, 0, density: 72)
+        get_mime_type(single_pages.path).must_include "image/png"
+      end
+
+      # ---------------------------------------------------------------------
+
+      describe 'single pages' do
+        it 'renders page' do
+          skip
+          processor.call(single_pages, 1, density: 72)
+        end
+      end
+
+      describe 'spreads' do
+        it 'recalculates the page number correctly' do
+          skip
+          processor.call(spreads, 3, density: 72, spreads: true)
+        end
+      end
+
+      describe 'spreads_back' do
+        it 'recalculates the page number correctly' do
+          skip
+          processor.call(spreads_back, 3, density: 72, spreads: true)
+        end
+      end
+
+      describe 'spreads_cover' do
+        it 'recalculates the page number correctly' do
+          skip
+          processor.call(spreads_cover, 3, density: 72, spreads: true)
+        end
+      end
+
+      describe 'spreads_cover_back' do
+        it 'recalculates the page number correctly' do
+          skip
+          processor.call(spreads_cover_back, 3, density: 72, spreads: true)
+        end
+      end
+
+      # ---------------------------------------------------------------------
+      
+      def get_mime_type file_path
+        `file --mime-type #{file_path}`.gsub(/\n/, "")
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+require 'bundler/setup'
+
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/spec'
+
+require 'dragonfly'
+require 'dragonfly_pdf'
+
+# ---------------------------------------------------------------------
+
+SAMPLES_DIR = Pathname.new(File.expand_path('../../samples', __FILE__))
+
+# ---------------------------------------------------------------------
+
+def test_app name=nil
+  app = Dragonfly::App.instance(name)
+  app.datastore = Dragonfly::MemoryDataStore.new
+  app.secret = "test secret"
+  app
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: dragonfly_pdf
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tomas Celizna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dragonfly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pdf-reader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Dragonfly PDF analysers and processors.
+email:
+- tomas.celizna@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- dragonfly_pdf.gemspec
+- lib/dragonfly_pdf.rb
+- lib/dragonfly_pdf/analysers/pdf_properties.rb
+- lib/dragonfly_pdf/plugin.rb
+- lib/dragonfly_pdf/processors/page_thumb.rb
+- lib/dragonfly_pdf/version.rb
+- samples/sample_pages.pdf
+- samples/sample_spreads.pdf
+- samples/sample_spreads_back.pdf
+- samples/sample_spreads_cover.pdf
+- samples/sample_spreads_cover_back.pdf
+- test/dragonfly_pdf/analysers/pdf_properties_test.rb
+- test/dragonfly_pdf/plugin_test.rb
+- test/dragonfly_pdf/processors/page_thumb_test.rb
+- test/test_helper.rb
+homepage: https://github.com/tomasc/dragonfly_pdf
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Dragonfly PDF analysers and processors.
+test_files:
+- test/dragonfly_pdf/analysers/pdf_properties_test.rb
+- test/dragonfly_pdf/plugin_test.rb
+- test/dragonfly_pdf/processors/page_thumb_test.rb
+- test/test_helper.rb