dragonfly_pdf 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ee23007036641281d4325d303511da0796a1f6a
-  data.tar.gz: 2c83a852242b6cb5f78f69c96fba43b7900e2959
+  metadata.gz: 2750c91307336a07aaadcbb6ff558becd185dd43
+  data.tar.gz: 45dc9c8d207ef6a5df210012bea76f5b70c621f7
 SHA512:
-  metadata.gz: 701c02304a959ed3757befceb4e708bd1cbca373efab15150b760c78671910a1156f7d808a88c7a6b4ef451a82c4e08215a448600d63cd56259e3df4b9386972
-  data.tar.gz: 0bb95b962d22d78e76dc21e4b47c58160210e9bd054f71f8e3d6278aec5447b03166f5a1a60f9b8b64c5be98377b10053f8d0627392e3b51855b424e91d28745
+  metadata.gz: 202b5f48965ab0182b5988209057c4383b3b6401b994eac9e07e2d4ef373b390b074f9e175a8ea711fb7f9e576d4f6f13520266c34d42a7d78621aa0d3d6f34a
+  data.tar.gz: 19562c74566b4f386876d331e61d981b5cae9d533be5ca6f30bcb24a1355b149ae656af0decf512a0976043b95011997955dcc4fa12044864464bf406603b116

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+cache: bundler
+script: 'bundle exec rake'
+rvm:
+  - 2.1.2
+before_install:
+  - gem update bundler
+notifications:
+  email:
+    recipients:
+      - tomas.celizna@gmail.com
+      - asger@8kilo.com
+    on_failure: change
+    on_success: never

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## 0.1.0
+
+* added: `page_dimensions`
+* fixed: calculating page dimensions based on crop area
+* removed: the `spread` setting and related calculations have been removed (the logic is better situated on a model using the PDF)

data/README.md

@@ -32,14 +32,6 @@ Dragonfly.app.configure do
 end
 ```
 
-### Spreads
-
-PDFs that contain spreads (as when saving with the spreads option in InDesign) require setting the `spreads` [metadata](http://markevans.github.io/dragonfly/models/#meta-data) attribute to `true`:
-
-```ruby
-pdf.meta['spreads'] = true
-```
-
 ## Analysers
 
 ### PDF properties
@@ -55,16 +47,14 @@ It returns a hash of 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]]
+    page_dimensions: [[210.0, 297.0], [210.0, 297.0], [210.0, 297.0], [210.0, 297.0]],
+    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]
 }
 ```
 
-When the `spreads` metadata is set to `true`, the analyser assumes the PDF contains 2 real pages per one PDF page and recalculates the PDF properties accordingly (including situations where the PDF begins or ends with a single page). All page arrays (`page_numbers`, `widths`, `heights`, `aspect_ratios`) are then two dimensional (as illustrated above), representing spreads and nested individual pages.
-
 ## Processors
 
 ### Page

data/dragonfly_pdf.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
   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 "pdf-reader"
+  spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-minitest"

data/lib/dragonfly_pdf/analysers/pdf_properties.rb

@@ -3,147 +3,68 @@ require 'pdf-reader'
 module DragonflyPdf
   module Analysers
     class PdfProperties
-
-      def call content
-        spreads = content.meta['spreads'] || false
-
-        pdf = PDF::Reader.new(content.file)
-
+      def call(content, options = {})
+        @content = content
+        @use_cropbox = options.fetch :use_cropbox, true
+        @use_trimbox = options.fetch :use_trimbox, true
         {
-          aspect_ratios: aspect_ratios(pdf, spreads),
-          heights: heights(pdf, spreads),
-          page_count: page_count(pdf, spreads),
-          page_numbers: page_numbers(pdf, spreads),
-          spread_count: spread_count(pdf, spreads),
-          widths: widths(pdf, spreads)
+          aspect_ratios: aspect_ratios,
+          heights: heights,
+          page_count: page_count,
+          page_dimensions: page_dimensions,
+          page_numbers: page_numbers,
+          widths: widths
         }
       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
+      def page_dimensions
+        @page_dimensions ||= begin
+          res = @content.shell_eval do |path|
+            "#{identify_command} -format '%Wx%H,' #{path}"
           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]
+          res.to_s.split(/\s*,\s*/).compact.map do |page|
+            page = page.split(/\s*x\s*/).map(&:to_f).map { |n| pt2mm(n) }
           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)
+      def widths
+        page_dimensions.inject([]) do |res, page|
+          res << page[0]
         end
+      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
+      def heights
+        page_dimensions.inject([]) do |res, page|
+          res << page[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
+      def aspect_ratios
+        page_dimensions.inject([]) do |res, page|
+          res << page[0] / page[1]
         end
-
-        res
       end
 
-      # ---------------------------------------------------------------------
-
-      def page_count pdf, spreads
-        page_numbers(pdf, spreads).flatten.count
+      def page_numbers
+        (1..page_count).to_a
       end
 
-      def spread_count pdf, spreads
-        return 0 unless spreads
-        page_numbers(pdf, spreads).count
+      def page_count
+        page_dimensions.count
       end
 
       # =====================================================================
 
-      def pt2mm pt
+      def pt2mm(pt)
         (pt / 72.0) * 25.4
       end
 
+      def identify_command
+        "identify -define pdf:use-cropbox=#{@use_cropbox} -define pdf:use-trimbox=#{@use_trimbox}"
+      end
     end
   end
 end

data/lib/dragonfly_pdf/plugin.rb

@@ -1,12 +1,10 @@
 require 'dragonfly_pdf/analysers/pdf_properties'
-
 require 'dragonfly_pdf/processors/page'
 require 'dragonfly_pdf/processors/page_thumb'
 require 'dragonfly_pdf/processors/subset_fonts'
 
 module DragonflyPdf
   class Plugin
-
     def call app, opts={}
       app.add_analyser :pdf_properties, DragonflyPdf::Analysers::PdfProperties.new
 
@@ -14,14 +12,14 @@ module DragonflyPdf
         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 :page_dimensions do |content|
+        content.analyse(:pdf_properties)[:page_dimensions]
+      end
+
       app.add_analyser :widths do |content|
         content.analyse(:pdf_properties)[:widths]
       end
@@ -34,17 +32,12 @@ module DragonflyPdf
         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
       app.add_processor :page, DragonflyPdf::Processors::Page.new
       app.add_processor :subset_fonts, DragonflyPdf::Processors::SubsetFonts.new
     end
-
   end
 end
 

data/lib/dragonfly_pdf/processors/page.rb

@@ -5,46 +5,26 @@ require_relative '../analysers/pdf_properties'
 module DragonflyPdf
   module Processors
     class Page
+      def call(content, page_number = 1, _opts = {})
+        @content = content
+        @page_number = page_number
 
-      def call content, page_number=1, opts={}
-        spreads = content.meta['spreads'] || false
-        pdf_page_number = page_number
-        crop_args = ''
+        fail DragonflyPdf::PageNotFound unless pdf_properties[:page_numbers].include?(page_number)
 
-        pdf_properties = DragonflyPdf::Analysers::PdfProperties.new.call(content)
-
-        raise DragonflyPdf::PageNotFound unless pdf_properties[:page_numbers].flatten.include?(page_number)
-
-        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)
-
-          pdf_page_number = spread_number+1
-
-          pdf = PDF::Reader.new(content.path)
-          box = pdf.pages[spread_number].attributes[:MediaBox] || pdf.pages[spread_number].attributes[:CropBox]
-
-          crop_box = box
-          crop_box[2] = crop_box[2]/2
-          crop_box[0] += crop_box[2] * spread_side
-          crop_box[2] += crop_box[2] * spread_side
-
-          crop_args = "-c '[/CropBox [#{crop_box.join(' ')}] /PAGES pdfmark'"
-        end
-
-        content.shell_update(ext: :pdf) do |old_path, new_path|
-          "#{gs_command} -sDEVICE=pdfwrite -dNOPAUSE -dBATCH -dFirstPage=#{pdf_page_number} -dLastPage=#{pdf_page_number} -o #{new_path} #{crop_args} -f #{old_path}"
+        @content.shell_update(ext: :pdf) do |old_path, new_path|
+          "#{gs_command} -dFirstPage=#{@page_number} -dLastPage=#{@page_number} -o #{new_path} -f #{old_path}"
         end
       end
 
-
       private # =============================================================
-      
+
       def gs_command
-        'gs'
+        'gs -sDEVICE=pdfwrite -dNOPAUSE -dBATCH'
       end
 
+      def pdf_properties
+        @pdf_properties ||= DragonflyPdf::Analysers::PdfProperties.new.call(@content)
+      end
     end
   end
 end

data/lib/dragonfly_pdf/processors/page_thumb.rb

@@ -3,40 +3,23 @@ require_relative '../analysers/pdf_properties'
 module DragonflyPdf
   module Processors
     class PageThumb
+      def call(content, page_number = 1, opts = {})
+        @content = content
+        @page_number = page_number
+        @format = opts['format'] || :png
+        @density = opts['density'] || 150
 
-      def call content, page_number=1, opts={}
-        format = opts['format'] || :png
-        density = opts['density'] || 150
-        spreads = content.meta['spreads'] || false
+        fail DragonflyPdf::PageNotFound unless pdf_properties[:page_numbers].include?(@page_number)
 
-        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)
-
-        raise DragonflyPdf::PageNotFound unless pdf_properties[:page_numbers].flatten.include?(page_number)
-
-        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-1
+        content.shell_update(ext: @format) do |old_path, new_path|
+          "#{convert_command} #{old_path}[#{pdf_page_number}] #{new_path}"
         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
+        @content.meta['format'] = @format.to_s
+        @content.ext = @format
       end
 
-      def update_url attrs, page_number, opts={}
+      def update_url(attrs, page_number, opts = {})
         format = opts['format']
         attrs.page_number = page_number
         attrs.ext = format if format
@@ -44,18 +27,17 @@ module DragonflyPdf
 
       private # =============================================================
 
-      def convert_command
-        'convert'
+      def pdf_properties
+        @pdf_properties ||= DragonflyPdf::Analysers::PdfProperties.new.call(@content)
       end
 
-      def pdf_page_number page_number, spreads
-        return 1
+      def convert_command
+        "convert -alpha deactivate -background white -colorspace sRGB -density #{@density}x#{@density} -define pdf:use-cropbox=true -define pdf:use-trimbox=true"
       end
 
-      def pdf_crop_args page_number, spreads
-        return
+      def pdf_page_number
+        @page_number - 1
       end
-
     end
   end
 end

data/lib/dragonfly_pdf/processors/subset_fonts.rb

@@ -1,20 +1,17 @@
 module DragonflyPdf
   module Processors
     class SubsetFonts
-
       def call content, opts={}
         content.shell_update(ext: :pdf) do |old_path, new_path|
-          "#{gs_command} -sDEVICE=pdfwrite -dNOPAUSE -dBATCH -dSubsetFonts=true -o #{new_path} -f #{old_path}"
+          "#{gs_command} -o #{new_path} -f #{old_path}"
         end
       end
 
-
       private # =============================================================
 
       def gs_command
-        'gs'
+        "gs -sDEVICE=pdfwrite -dNOPAUSE -dBATCH -dSubsetFonts=true"
       end
-
     end
   end
 end

data/lib/dragonfly_pdf/version.rb

@@ -1,3 +1,3 @@
 module DragonflyPdf
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/lib/dragonfly_pdf.rb

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

data/test/dragonfly_pdf/analysers/pdf_properties_test.rb

@@ -3,235 +3,56 @@ require 'test_helper'
 module DragonflyPdf
   module Analysers
     describe PdfProperties do
-
       let(:app) { test_app.configure_with(:pdf) }
       let(:analyser) { DragonflyPdf::Analysers::PdfProperties.new }
+      let(:sample_pages) { app.fetch_file(SAMPLES_DIR.join('sample_pages.pdf')) }
+      let(:sample_pages_with_bleed) { app.fetch_file(SAMPLES_DIR.join('sample_pages_with_bleed.pdf')) }
 
-      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')) }
-
-      before do
-        spreads.meta['spreads'] = true
-        spreads_cover.meta['spreads'] = true
-        spreads_back.meta['spreads'] = true
-        spreads_cover_back.meta['spreads'] = true
-      end
-
-      describe 'call' do
-        let(:pdf_properties) { analyser.call(single_pages) }
+      # =====================================================================
 
-        it 'returns Hash' do
-          pdf_properties.must_be_kind_of Hash
-        end
+      it 'returns Hash' do
+        analyser.call(sample_pages).must_be_kind_of Hash
       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)[: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)[: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)[: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)[:page_numbers].must_equal [[1],[2,3],[4,5],[6,7],[8,9],[10]]
-          end
+        it 'returns one-dimensional array' do
+          analyser.call(sample_pages)[:page_numbers].must_equal (1..10).to_a
         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)[: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)[: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)[: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)[:page_count].must_equal 10
-          end
+        it 'returns correct page count' do
+          analyser.call(sample_pages)[:page_count].must_equal 10
         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)[: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)[: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)[: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)[:spread_count].must_equal 6
-          end
+      describe '#page_dimensions' do
+        it 'returns widths' do
+          analyser.call(sample_pages)[:page_dimensions].map{ |p| p.map(&:round) }.must_equal [[210, 297]].cycle.take(10)
+          analyser.call(sample_pages_with_bleed)[:page_dimensions].map{ |p| p.map(&:round) }.must_equal [[210, 297]].cycle.take(10)
         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)[: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)[: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)[: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)[:widths].must_equal [[210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0, 210.0], [210.0]]
-          end
+        it 'returns widths' do
+          analyser.call(sample_pages)[:widths].map(&:round).must_equal [210].cycle.take(10)
+          analyser.call(sample_pages_with_bleed)[:widths].map(&:round).must_equal [210].cycle.take(10)
         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)[: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)[: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)[: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)[:heights].must_equal [[297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0, 297.0], [297.0]]
-          end
+        it 'returns heights' do
+          analyser.call(sample_pages)[:heights].map(&:round).must_equal [297].cycle.take(10)
+          analyser.call(sample_pages_with_bleed)[:heights].map(&:round).must_equal [297].cycle.take(10)
         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)[: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)[: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)[: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)[: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
+        it 'returns aspect ratios' do
+          analyser.call(sample_pages)[:aspect_ratios].map{ |i| i.round(2) }.must_equal [0.71].cycle.take(10)
+          analyser.call(sample_pages_with_bleed)[:aspect_ratios].map{ |i| i.round(2) }.must_equal [0.71].cycle.take(10)
         end
       end
-
     end
   end
 end

data/test/dragonfly_pdf/plugin_test.rb

@@ -2,7 +2,6 @@ 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')) }
 
@@ -12,30 +11,34 @@ module DragonflyPdf
       it 'adds #pdf_properties' do
         pdf.must_respond_to :pdf_properties
       end
+
       it 'allows an options parameter on #pdf_properties' do
         pdf.pdf_properties.must_be_kind_of Hash
       end
+
       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 #page_dimensions' do
+        pdf.must_respond_to :page_dimensions
+      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
 
     # ---------------------------------------------------------------------
@@ -48,6 +51,5 @@ module DragonflyPdf
         pdf.must_respond_to :page_thumb
       end
     end
-
   end
-end
+end

data/test/dragonfly_pdf/processors/page_test.rb

@@ -4,88 +4,36 @@ require 'pdf-reader'
 module DragonflyPdf
   module Processors
     describe Page do
-
       let(:app) { test_app.configure_with(:pdf) }
       let(:processor) { DragonflyPdf::Processors::Page.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')) }
-
-      before do
-        spreads.meta['spreads'] = true
-        spreads_cover.meta['spreads'] = true
-        spreads_back.meta['spreads'] = true
-        spreads_cover_back.meta['spreads'] = true
-      end
+      let(:sample_pages) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_pages.pdf')) }
 
       # =====================================================================
 
       it 'returns PDF by default' do
-        processor.call(single_pages, 1)
-        get_mime_type(single_pages.path).must_include "application/pdf"
+        processor.call(sample_pages, 1)
+        get_mime_type(sample_pages.path).must_include 'application/pdf'
       end
 
       it 'raises PageNotFound error' do
-        proc { processor.call(single_pages, 0) }.must_raise DragonflyPdf::PageNotFound
-        proc { processor.call(single_pages, 11) }.must_raise DragonflyPdf::PageNotFound
+        proc { processor.call(sample_pages, 0) }.must_raise DragonflyPdf::PageNotFound
+        proc { processor.call(sample_pages, 11) }.must_raise DragonflyPdf::PageNotFound
       end
 
-      # ---------------------------------------------------------------------
-
       describe 'single pages' do
         it 'renders page' do
-          processor.call(single_pages, 1)
-          pdf = PDF::Reader.new(single_pages.path)
+          processor.call(sample_pages, 1)
+          pdf = PDF::Reader.new(sample_pages.path)
           pdf.pages.count.must_equal 1
           pdf.pages.first.text.must_equal '1'
         end
       end
 
-      describe 'spreads' do
-        it 'recalculates the page number correctly' do
-          processor.call(spreads, 8, spreads: true)
-          pdf = PDF::Reader.new(spreads.path)
-          pdf.pages.count.must_equal 1
-          pdf.pages.first.text.must_include '8'
-        end
-      end
-
-      describe 'spreads_back' do
-        it 'recalculates the page number correctly' do
-          processor.call(spreads_back, 9, spreads: true)
-          pdf = PDF::Reader.new(spreads_back.path)
-          pdf.pages.count.must_equal 1
-          pdf.pages.first.text.must_include '9'
-        end
-      end
-
-      describe 'spreads_cover' do
-        it 'recalculates the page number correctly' do
-          processor.call(spreads_cover, 9, spreads: true)
-          pdf = PDF::Reader.new(spreads_cover.path)
-          pdf.pages.count.must_equal 1
-          pdf.pages.first.text.must_include '9'
-        end
-      end
-
-      describe 'spreads_cover_back' do
-        it 'recalculates the page number correctly' do
-          processor.call(spreads_cover_back, 10, spreads: true)
-          pdf = PDF::Reader.new(spreads_cover_back.path)
-          pdf.pages.count.must_equal 1
-          pdf.pages.first.text.must_include '10'
-        end
-      end
-
       # ---------------------------------------------------------------------
 
-      def get_mime_type file_path
-        `file --mime-type #{file_path}`.gsub(/\n/, "")
+      def get_mime_type(file_path)
+        `file --mime-type #{file_path}`.gsub(/\n/, '')
       end
-
     end
   end
 end

data/test/dragonfly_pdf/processors/page_thumb_test.rb

@@ -4,78 +4,31 @@ 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')) }
-
-      before do
-        spreads.meta['spreads'] = true
-        spreads_cover.meta['spreads'] = true
-        spreads_back.meta['spreads'] = true
-        spreads_cover_back.meta['spreads'] = true
-      end
+      let(:sample_pages) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_pages.pdf')) }
 
       # =====================================================================
 
       it 'returns PNG by default' do
-        processor.call(single_pages, 1, density: 72)
-        get_mime_type(single_pages.path).must_include "image/png"
+        processor.call(sample_pages, 1, density: 72)
+        get_mime_type(sample_pages.path).must_include 'image/png'
       end
 
       it 'raises PageNotFound error' do
-        proc { processor.call(single_pages, 0) }.must_raise DragonflyPdf::PageNotFound
-        proc { processor.call(single_pages, 11) }.must_raise DragonflyPdf::PageNotFound
-      end
-
-      # ---------------------------------------------------------------------
-
-      describe 'single pages' do
-        it 'renders page' do
-          skip
-          processor.call(single_pages, 1, density: 72)
-        end
+        proc { processor.call(sample_pages, 0) }.must_raise DragonflyPdf::PageNotFound
+        proc { processor.call(sample_pages, 11) }.must_raise DragonflyPdf::PageNotFound
       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
+      it 'renders page' do
+        processor.call(sample_pages, 1, density: 72)
       end
 
       # ---------------------------------------------------------------------
 
-      def get_mime_type file_path
-        `file --mime-type #{file_path}`.gsub(/\n/, "")
+      def get_mime_type(file_path)
+        `file --mime-type #{file_path}`.gsub(/\n/, '')
       end
-
     end
   end
-end
+end

data/test/dragonfly_pdf/processors/subset_fonts.rb

@@ -1,17 +1,15 @@
 module DragonflyPdf
   module Processors
     describe SubsetFonts do
-
       let(:app) { test_app.configure_with(:pdf) }
       let(:processor) { DragonflyPdf::Processors::SubsetFonts.new }
-
-      let(:sample_pdf) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_pages.pdf')) }
+      let(:sample_pages) { Dragonfly::Content.new(app, SAMPLES_DIR.join('sample_pages.pdf')) }
 
       # =====================================================================
 
       it 'returns PDF by default' do
-        processor.call(sample_pdf, 1)
-        get_mime_type(sample_pdf.path).must_include "application/pdf"
+        processor.call(sample_pages, 1)
+        get_mime_type(sample_pages.path).must_include "application/pdf"
       end
 
       private # =============================================================
@@ -19,7 +17,6 @@ module DragonflyPdf
       def get_mime_type file_path
         `file --mime-type #{file_path}`.gsub(/\n/, "")
       end
-
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dragonfly_pdf
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Tomas Celizna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-14 00:00:00.000000000 Z
+date: 2015-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dragonfly
@@ -28,30 +28,30 @@ dependencies:
   name: pdf-reader
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -116,6 +116,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE
@@ -131,10 +133,7 @@ files:
 - lib/dragonfly_pdf/processors/subset_fonts.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
+- samples/sample_pages_with_bleed.pdf
 - test/dragonfly_pdf/analysers/pdf_properties_test.rb
 - test/dragonfly_pdf/plugin_test.rb
 - test/dragonfly_pdf/processors/page_test.rb