preflight 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1,4 +1,11 @@
-v0.1.0 (6th July 2011)
+v0.2.0 (25th March 2012)
+- BREAKING API CHANGES FROM 0.1.1 release
+  - Detected issues are reported with an Issue object instead of a simple string
+- new rules
+- bug fixes and improvements to existing rules
+- improved documentation
+
+v0.1.1 (6th July 2011)
 - bump required version of PDF::Reader to take advantage of a more
   efficient API
 

data/README.rdoc

@@ -13,6 +13,10 @@ difficult to script and you know, expensive.
 This may not check as comprehensively as the official preflight tools from Adobe
 and friends, but hopefully it'll get you most of the way with less stress.
 
+Unlike some preflight tools, this library doesn't attempt to fix any issues. It
+only reports them. That may change one day, but for now you will need to fix
+any issues that are detected by using some other tool.
+
 == Installation
 
   gem install preflight
@@ -77,9 +81,8 @@ Use an existing rule set as the base for a larger set of rules.
 
 === Adding Rules to a Profile Instance
 
-Use an existing rule set as the base for a larger set of rules by adding
-rules to a profile instance. Useful when the required set of rules depends
-dynamic conditions.
+Dynamically add rules to a profile instance. Useful when the required set of
+rules depends on dynamic conditions like user input or database entries.
 
   require "preflight"
 
@@ -88,6 +91,21 @@ dynamic conditions.
 
   puts preflight.check("somefile.pdf").inspect
 
+=== Available Rules
+
+All rules shipped with this gem are in the Preflight::Rules namespace. Explore
+the classes and related documentation in there to see what's available.
+
+If you need a rule that we don't ship it is perfectly valid to build your own.
+A profile will accept any class that behaves appropriately. If you think your
+new rule may be of general interest please send me a pull request so I can
+include it in the next release.
+
+I'm yet to document the API that a rule class must follow. There are two
+types of rule, each designed to check a different aspect of the target file
+- raw PDF objects and individual pages. At this stage your best option when
+writing your own rule is to copy an existing rule as a starting point.
+
 == Status
 
 This library is in an early stage of development. Use at your own risk.
@@ -98,7 +116,6 @@ This is pure ruby should run on most ruby VMs. I develop on MRI 1.9.2.
 
 == Further Reading
 
-* http://chneukirchen.github.com/rps/
 * http://en.wikipedia.org/wiki/PDF/A
 * http://en.wikipedia.org/wiki/PDF/X
 * http://www.planetpdf.com/planetpdf/pdfs/pdfx3_draft4.pdf

data/lib/preflight.rb

@@ -1,6 +1,7 @@
 require 'pdf/reader'
 
 require 'preflight/measurements'
+require 'preflight/issue'
 require 'preflight/profile'
 
 require 'preflight/rules'

data/lib/preflight/issue.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Preflight
+  class Issue
+
+    attr_reader :description, :rule, :attributes
+
+    def initialize(description, rule, attributes = {})
+      @description = description
+      if rule.is_a?(Class)
+        @rule = rule.to_s.to_sym
+      else
+        @rule        = rule.class.to_s.to_sym
+      end
+      @attributes  = attributes || {}
+
+      attach_attributes
+    end
+
+    def to_s
+      @description
+    end
+
+    private
+
+    def attach_attributes
+      singleton = class << self; self end
+
+      @attributes.each do |key, value|
+        singleton.send(:define_method, key, lambda { value })
+      end
+    end
+
+  end
+end

data/lib/preflight/profile.rb

@@ -36,6 +36,8 @@ module Preflight
 
     module InstanceMethods
       def check(input)
+        valid_rules?
+
         if File.file?(input)
           check_filename(input)
         elsif input.is_a?(IO)
@@ -58,7 +60,12 @@ module Preflight
       end
 
       def check_io(io)
-        check_receivers(io) + check_hash(io)
+        PDF::Reader.open(io) do |reader|
+          raise PDF::Reader::EncryptedPDFError if reader.objects.encrypted?
+          check_pages(reader) + check_hash(reader)
+        end
+      rescue PDF::Reader::EncryptedPDFError
+        ["Can't preflight an encrypted PDF"]
       end
 
       def instance_rules
@@ -69,38 +76,53 @@ module Preflight
         self.class.rules + instance_rules
       end
 
-      def check_receivers(io)
-        rules_array = receiver_rules
+      def check_hash(reader)
+        hash_rules.map { |chk|
+          chk.check_hash(reader.objects)
+        }.flatten.compact
+      rescue PDF::Reader::UnsupportedFeatureError
+        []
+      end
+
+      def check_pages(reader)
+        rules_array = page_rules
+        issues    = []
+
         begin
-          PDF::Reader.new.parse(io, rules_array)
+          reader.pages.each do |page|
+            page.walk(*rules_array)
+            issues += rules_array.map(&:issues).flatten.compact
+          end
         rescue PDF::Reader::UnsupportedFeatureError
           nil
         end
-        rules_array.map(&:messages).flatten.compact
+        issues
       end
 
-      def check_hash(io)
-        ohash = PDF::Reader::ObjectHash.new(io)
-
-        hash_rules.map { |chk|
-          chk.messages(ohash)
-        }.flatten.compact
+      # ensure all rules follow the prescribed API
+      #
+      def valid_rules?
+        invalid_rules = all_rules.reject { |arr|
+          arr.first.instance_methods.map(&:to_sym).include?(:check_hash) ||
+            arr.first.instance_methods.map(&:to_sym).include?(:issues)
+        }
+        if invalid_rules.size > 0
+          raise "The following rules are invalid: #{invalid_rules.join(", ")}. Preflight rules MUST respond to either check_hash() or issues()."
+        end
       end
 
       def hash_rules
         all_rules.select { |arr|
-          meth = arr.first.instance_method(:messages)
-          meth && meth.arity == 1
+          arr.first.instance_methods.map(&:to_sym).include?(:check_hash)
         }.map { |arr|
           klass = arr[0]
           klass.new(*arr[1,10])
         }
       end
 
-      def receiver_rules
+      def page_rules
         all_rules.select { |arr|
-          meth = arr.first.instance_method(:messages)
-          meth && meth.arity == 0
+          arr.first.instance_methods.map(&:to_sym).include?(:issues)
         }.map { |arr|
           klass = arr[0]
           klass.new(*arr[1,10])

data/lib/preflight/profiles/pdfa1a.rb

@@ -9,7 +9,6 @@ module Preflight
 
       # hard failures of the pdfx/1a spec
       rule Preflight::Rules::CompressionAlgorithms, :CCITTFaxDecode, :DCTDecode, :FlateDecode, :RunLengthDecode
-      rule Preflight::Rules::NoEncryption
       rule Preflight::Rules::OnlyEmbeddedFonts
 
     end

data/lib/preflight/profiles/pdfx1a.rb

@@ -12,16 +12,17 @@ module Preflight
       rule Preflight::Rules::RootHasKeys, :OutputIntents
       rule Preflight::Rules::InfoHasKeys, :Title, :CreationDate, :ModDate
       rule Preflight::Rules::InfoSpecifiesTrapping
-      rule Preflight::Rules::CompressionAlgorithms, :CCITTFaxDecode, :DCTDecode, :FlateDecode, :RunLengthDecode
+      rule Preflight::Rules::CompressionAlgorithms, :ASCII85Decode, :CCITTFaxDecode, :DCTDecode, :FlateDecode, :RunLengthDecode
       rule Preflight::Rules::DocumentId
-      rule Preflight::Rules::NoEncryption
       rule Preflight::Rules::NoFilespecs
+      rule Preflight::Rules::NoTransparency
       rule Preflight::Rules::OnlyEmbeddedFonts
       rule Preflight::Rules::BoxNesting
-      rule Preflight::Rules::MaxVersion, 1.4
+      rule Preflight::Rules::MaxVersion, 1.3
       rule Preflight::Rules::PrintBoxes
       rule Preflight::Rules::OutputIntentForPdfx
       rule Preflight::Rules::PdfxOutputIntentHasKeys, :OutputConditionIdentifier, :Info
+      rule Preflight::Rules::NoRgb
 
     end
   end

data/lib/preflight/rules.rb

@@ -1,17 +1,32 @@
 require 'preflight/rules/box_nesting'
 require 'preflight/rules/compression_algorithms'
+require 'preflight/rules/consistent_boxes'
+require 'preflight/rules/cropbox_matches_mediabox'
 require 'preflight/rules/document_id'
 require 'preflight/rules/info_has_keys'
 require 'preflight/rules/info_specifies_trapping'
 require 'preflight/rules/match_info_entries'
+require 'preflight/rules/max_ink_density'
 require 'preflight/rules/max_version'
+require 'preflight/rules/mediabox_at_origin'
+require 'preflight/rules/min_bleed'
 require 'preflight/rules/min_ppi'
-require 'preflight/rules/no_encryption'
+require 'preflight/rules/no_cmyk'
 require 'preflight/rules/no_filespecs'
 require 'preflight/rules/no_font_subsets'
-require 'preflight/rules/no_proprietary_fonts'
+require 'preflight/rules/no_gray'
+require 'preflight/rules/no_page_rotation'
+require 'preflight/rules/no_registration_black'
+require 'preflight/rules/no_rgb'
+require 'preflight/rules/no_private_data'
+require 'preflight/rules/no_separation'
+require 'preflight/rules/no_transparency'
 require 'preflight/rules/only_embedded_fonts'
 require 'preflight/rules/output_intent_for_pdfx'
+require 'preflight/rules/page_count'
+require 'preflight/rules/page_box_height'
+require 'preflight/rules/page_box_width'
+require 'preflight/rules/page_box_size'
 require 'preflight/rules/pdfx_output_intent_has_keys'
 require 'preflight/rules/print_boxes'
 require 'preflight/rules/root_has_keys'

data/lib/preflight/rules/box_nesting.rb

@@ -6,38 +6,50 @@ module Preflight
     # For each page MediaBox must be the biggest box, followed by the
     # BleedBox or ArtBox, followed by the TrimBox.
     #
+    # Boxes may be omitted, but if they're provided they must be correctly nested.
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::BoxNesting
+    #   end
+    #
     class BoxNesting
-      attr_reader :messages
-
-      def initialize
-        @messages = []
-        @page_num = 0
-        @parent   = {}
-      end
-
-      def begin_page_container(hash = {})
-        @parent.merge!(hash)
-      end
 
-      def begin_page(hash = {})
-        @page_num += 1
-        hash = @parent.merge(hash)
+      attr_reader :issues
 
-        media  = hash[:MediaBox]
-        bleed  = hash[:BleedBox]
-        trim   = hash[:TrimBox]
-        art    = hash[:ArtBox]
+      def page=(page)
+        media  = page.attributes[:MediaBox]
+        bleed  = page.attributes[:BleedBox]
+        trim   = page.attributes[:TrimBox]
+        art    = page.attributes[:ArtBox]
 
         if media && bleed && (bleed[2] > media[2] || bleed[3] > media[3])
-          @messages << "BleedBox must be smaller than MediaBox (page #{@page_num})"
+          @issues = [Issue.new("BleedBox must be smaller than MediaBox", self, :page      => page.number,
+                                                                               :large_box => "BleedBox",
+                                                                               :small_box => "MediaBox")]
         elsif trim && bleed && (trim[2] > bleed[2] || trim[3] > bleed[3])
-          @messages << "TrimBox must be smaller than BleedBox (page #{@page_num})"
+          @issues = [Issue.new("TrimBox must be smaller than BleedBox", self, :page      => page.number,
+                                                                              :large_box => "TrimBox",
+                                                                              :small_box => "BleedBox")]
         elsif art && bleed && (art[2] > bleed[2] || art[3] > bleed[3])
-          @messages << "ArtBox must be smaller than BleedBox (page #{@page_num})"
+          @issues = [Issue.new("ArtBox must be smaller than BleedBox", self, :page       => page.number,
+                                                                             :large_box => "ArtBox",
+                                                                             :small_box => "BleedBox")]
         elsif trim && media && (trim[2] > media[2] || trim[3] > media[3])
-          @messages << "TrimBox must be smaller than MediaBox (page #{@page_num})"
+          @issues = [Issue.new("TrimBox must be smaller than MediaBox", self, :page      => page.number,
+                                                                              :large_box => "TrimBox",
+                                                                              :small_box => "MediaBox")]
         elsif art && media && (art[2] > media[2] || art[3] > media[3])
-          @messages << "ArtBox must be smaller than MediaBox (page #{@page_num})"
+          @issues = [Issue.new("ArtBox must be smaller than MediaBox", self, :page      => page.number,
+                                                                             :large_box => "ArtBox",
+                                                                             :small_box => "MediaBox")]
+        else
+          @issues = []
         end
       end
     end

data/lib/preflight/rules/compression_algorithms.rb

@@ -3,19 +3,29 @@
 module Preflight
   module Rules
 
-    # check a file only uses permitted compression algorithms
+    # check a file doesn't use unwanted compression algorithms
+    #
+    # Arguments: a list of permitted compression algorithms.
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::CompressionAlgorithms, :CCITTFaxDecode, :DCTDecode, :FlateDecode
+    #   end
     #
     class CompressionAlgorithms
 
       def initialize(*algorithms)
-        @algorithms = algorithms.flatten 
+        @algorithms = algorithms.flatten
       end
 
-      def messages(ohash)
+      def check_hash(ohash)
         algorithms = banned_algorithms(ohash)
 
         if algorithms.size > 0
-          ["File uses excluded compression algorithm (#{algorithms.join(", ")})"]
+          [Issue.new("File uses excluded compression algorithm", self, :algorithms => algorithms)]
         else
           []
         end

data/lib/preflight/rules/consistent_boxes.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # Every page should have identical page boxes
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::BoxNesting
+    #   end
+    #
+    class ConsistentBoxes
+
+      # each page box MUST be within .03 PDF points of the same box
+      # on all other pages
+      TOLERANCE = (BigDecimal.new("-0.03")..BigDecimal.new("0.03"))
+
+      attr_reader :issues
+
+      def initialize
+        @boxes = {}
+      end
+
+      def page=(page)
+        @issues = []
+        dict = page.attributes
+
+        @boxes[:MediaBox] ||= dict[:MediaBox]
+        @boxes[:CropBox]  ||= dict[:CropBox]
+        @boxes[:BleedBox] ||= dict[:BleedBox]
+        @boxes[:TrimBox]  ||= dict[:TrimBox]
+        @boxes[:ArtBox]   ||= dict[:ArtBox]
+
+        %w(MediaBox CropBox BleedBox TrimBox ArtBox).map(&:to_sym).each do |box_type|
+          unless subtract_all(@boxes[box_type], dict[box_type]).all? { |diff| TOLERANCE.include?(diff) }
+            @issues << Issue.new("#{box_type} must be consistent across every page", self, :page             => page.number,
+                                                                                           :inconsistent_box => box_type)
+          end
+        end
+      end
+
+      private
+
+      def subtract_all(one, two)
+        one ||= [0, 0, 0, 0]
+        two ||= [0, 0, 0, 0]
+
+        [
+          one[0] - two[0],
+          one[1] - two[1],
+          one[2] - two[2],
+          one[3] - two[3]
+        ]
+      end
+    end
+  end
+end

data/lib/preflight/rules/cropbox_matches_mediabox.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # Every page should have a CropBox that matches the MediaBox
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::CropboxMatchesMediabox
+    #   end
+    #
+    class CropboxMatchesMediabox
+
+      attr_reader :issues
+
+      def page=(page)
+        @issues = []
+        dict = page.attributes
+
+        if dict[:CropBox] && round_off(dict[:CropBox]) != round_off(dict[:MediaBox])
+          @issues << Issue.new("CropBox must match MediaBox", self, :page => page.number)
+        end
+      end
+
+      private
+
+      def round_off(*arr)
+        arr.flatten.compact.map { |n| BigDecimal.new(n.to_s).round(2) }
+      end
+    end
+  end
+end