preflight 0.0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+v0.0.1 (27th March 2011)
+* initial release

data/README.rdoc

@@ -0,0 +1,87 @@
+= Preflight
+
+Check your PDF files meet the standard you require.
+
+The full PDF spec is a beast, and there are any number of ways of producing a
+valid PDF.  Receivers of PDF files may need to ensure the files they're sent
+meet a particular set of requirements, be it PDF/X, PDF/A or just "images must
+be 300 dpi or greater". These checks are called preflight.
+
+There's expensive software around that can preflight for you, but it's often
+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.
+
+== Installation
+
+  gem install preflight
+
+== Usage
+
+== Standard Profile ( PDF/X-1a )
+
+  require "preflight"
+
+  preflight = Preflight::Profiles::PDFX1A.new
+
+  puts preflight.check("somefile.pdf").inspect
+
+  File.open("somefile.pdf", "rb") do |file|
+    puts preflight.check(file).inspect
+  end
+
+== Custom Profile
+
+  require "preflight"
+
+  class MyPreflight
+    include Preflight::Profile
+
+    profile_name "simple-pdf"
+
+    rule Preflight::Rules::MaxVersion, 1.4
+    rule Preflight::Rules::NoEncryption
+    rule Preflight::Rules::DocumentId
+  end
+
+  preflight = MyPreflight
+
+  puts preflight.check("somefile.pdf").inspect
+
+== Extend A Profile
+
+  require "preflight"
+
+  class MyPreflight
+    include Preflight::Profile
+
+    profile_name "simple-pdf"
+
+    import Preflight::Profiles::PDFX1A
+
+    rule Preflight::Rules::MaxVersion, 1.4
+    rule Preflight::Rules::NoEncryption
+    rule Preflight::Rules::DocumentId
+  end
+
+  preflight = MyPreflight
+
+  puts preflight.check("somefile.pdf").inspect
+
+== Status
+
+This library is in an early stage of development. Use at your own risk.
+
+== Compatability
+
+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
+* http://www.gwg.org/doc_pdfxfaq.phtml
+* http://www.pdfxreport.com/lib/exe/fetch.php?id=en%3Adownloads&cache=cache&media=en:technote_pdfx_checks.pdf

data/bin/is_pdfx_1a

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+begin
+  require 'preflight'
+rescue LoadError
+  require 'bundler'
+  Bundler.setup
+  $LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib/" 
+  require 'preflight'
+end
+
+filename  = ARGV.shift
+preflight = Preflight::Profiles::PDFX1A.new
+messages  = preflight.check(filename)
+
+messages.each do |msg|
+  $stderr.puts msg
+end
+
+exit messages.size

data/lib/preflight.rb

@@ -0,0 +1,11 @@
+require 'pdf/reader'
+
+require 'preflight/measurements'
+require 'preflight/profile'
+
+require 'preflight/rules'
+require 'preflight/profiles'
+
+module Preflight
+  VERSION = "0.0.1"
+end

data/lib/preflight/measurements.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+#
+
+require 'bigdecimal'
+
+module Preflight
+  module Measurements
+
+    private
+
+    # convert inches to standard PDF points
+    #
+    def in2pt(inch)
+      return inch * BigDecimal.new("72")
+    end
+
+    # convert mm to standard PDF points
+    #
+    def mm2pt(mm)
+      return mm * (BigDecimal.new("72") / BigDecimal.new("24.4"))
+    end
+
+    # convert mm to standard PDF points
+    #
+    def cm2pt(cm)
+      return cm * mm2pt(10)
+    end
+
+    # convert standard PDF points to inches
+    #
+    def pt2in(pt)
+      return pt / in2pt(1)
+    end
+
+    # convert standard PDF points to mm
+    #
+    def pt2mm(pt)
+      return pt / mm2pt(1)
+    end
+
+    # convert standard PDF points to cm
+    #
+    def pt2cm(pt)
+      return pt / cm2pt(1)
+    end
+  end
+end

data/lib/preflight/profile.rb

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+module Preflight
+
+  # base functionality for all profiles.
+  #
+  module Profile
+
+    def self.included(base) # :nodoc:
+      base.class_eval do
+        extend  Preflight::Profile::ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      def profile_name(str)
+        @profile_name = str
+      end
+
+      def import(profile)
+        profile.rules.each do |array|
+          rules << array.flatten
+        end
+      end
+
+      def rule(*args)
+        rules << args.flatten
+      end
+
+      def rules
+        @rules ||= []
+      end
+
+    end
+
+    module InstanceMethods
+      def check(input)
+        if File.file?(input)
+          check_filename(input)
+        elsif input.is_a?(IO)
+          check_io(input)
+        else
+          raise ArgumentError, "input must be a string with a filename or an IO object"
+        end
+      end
+
+      private
+
+      def check_filename(filename)
+        File.open(filename, "rb") do |file|
+          return check_io(file)
+        end
+      end
+
+      def check_io(io)
+        check_receivers(io) + check_hash(io)
+      end
+
+      # TODO: this is nasty, we parse the full file once for each receiver.
+      #       PDF::Reader needs to be updated to support multiple receivers
+      #
+      def check_receivers(io)
+        receiver_rules.map { |rec|
+          begin
+            PDF::Reader.new.parse(io, rec)
+            rec.messages
+          rescue PDF::Reader::UnsupportedFeatureError
+            nil
+          end
+        }.flatten.compact
+      end
+
+      def check_hash(io)
+        ohash = PDF::Reader::ObjectHash.new(io)
+
+        hash_rules.map { |chk|
+          chk.messages(ohash)
+        }.flatten.compact
+      end
+
+      def hash_rules
+        self.class.rules.select { |arr|
+          arr.first.rule_type == :hash
+        }.map { |arr|
+          klass = arr[0]
+          klass.new(*arr[1,10])
+        }
+      end
+
+      def receiver_rules
+        self.class.rules.select { |arr|
+          arr.first.rule_type == :receiver
+        }.map { |arr|
+          klass = arr[0]
+          klass.new(*arr[1,10])
+        }
+      end
+    end
+  end
+end

data/lib/preflight/profiles.rb

@@ -0,0 +1,2 @@
+require 'preflight/profiles/pdfa1a'
+require 'preflight/profiles/pdfx1a'

data/lib/preflight/profiles/pdfa1a.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+module Preflight
+  module Profiles
+    class PDFA1A
+      include Preflight::Profile
+
+      profile_name "pdfa-1a"
+
+      # hard failures of the pdfx/1a spec
+      rule Preflight::Rules::CompressionAlgorithms, :CCITTFaxDecode, :DCTDecode, :FlateDecode, :RunLengthDecode
+      rule Preflight::Rules::NoEncryption
+      rule Preflight::Rules::OnlyEmbeddedFonts
+
+    end
+  end
+end

data/lib/preflight/profiles/pdfx1a.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+module Preflight
+  module Profiles
+    class PDFX1A
+      include Preflight::Profile
+
+      profile_name "pdfx-1a"
+
+      rule Preflight::Rules::MatchInfoEntries, {:GTS_PDFXVersion => /\APDF\/X/,
+                                                :GTS_PDFXConformance => /\APDF\/X-1a/}
+      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::DocumentId
+      rule Preflight::Rules::NoEncryption
+      rule Preflight::Rules::OnlyEmbeddedFonts
+      rule Preflight::Rules::BoxNesting
+      rule Preflight::Rules::MaxVersion, 1.4
+      rule Preflight::Rules::PrintBoxes
+
+    end
+  end
+end

data/lib/preflight/rules.rb

@@ -0,0 +1,14 @@
+require 'preflight/rules/box_nesting'
+require 'preflight/rules/compression_algorithms'
+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_version'
+require 'preflight/rules/min_ppi'
+require 'preflight/rules/no_encryption'
+require 'preflight/rules/no_font_subsets'
+require 'preflight/rules/no_proprietary_fonts'
+require 'preflight/rules/only_embedded_fonts'
+require 'preflight/rules/print_boxes'
+require 'preflight/rules/root_has_keys'

data/lib/preflight/rules/box_nesting.rb

@@ -0,0 +1,43 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # For each page MediaBox must be the biggest box, followed by the
+    # BleedBox or ArtBox, followed by the TrimBox.
+    #
+    class BoxNesting
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+        @page_num = 0
+      end
+
+      def self.rule_type
+        :receiver
+      end
+
+      def begin_page(hash = {})
+        @page_num += 1
+
+        media  = hash[:MediaBox]
+        bleed  = hash[:BleedBox]
+        trim   = hash[:TrimBox]
+        art    = hash[:ArtBox]
+
+        if media && bleed && (bleed[2] > media[2] || bleed[3] > media[3])
+          @messages << "BleedBox must be smaller than MediaBox (page #{@page_num})"
+        elsif trim && bleed && (trim[2] > bleed[2] || trim[3] > bleed[3])
+          @messages << "TrimBox must be smaller than BleedBox (page #{@page_num})"
+        elsif art && bleed && (art[2] > bleed[2] || art[3] > bleed[3])
+          @messages << "ArtBox must be smaller than BleedBox (page #{@page_num})"
+        elsif trim && media && (trim[2] > media[2] || trim[3] > media[3])
+          @messages << "TrimBox must be smaller than MediaBox (page #{@page_num})"
+        elsif art && media && (art[2] > media[2] || art[3] > media[3])
+          @messages << "ArtBox must be smaller than MediaBox (page #{@page_num})"
+        end
+      end
+    end
+  end
+end

data/lib/preflight/rules/compression_algorithms.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # check a file only uses permitted compression algorithms
+    #
+    class CompressionAlgorithms
+
+      def initialize(*algorithms)
+        @algorithms = algorithms.flatten 
+      end
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        algorithms = banned_algorithms(ohash)
+
+        if algorithms.size > 0
+          ["File uses excluded compression algorithm (#{algorithms.join(", ")})"]
+        else
+          []
+        end
+      end
+
+      private
+
+      def banned_algorithms(ohash)
+        array = []
+        ohash.each do |key, obj|
+          if obj.is_a?(PDF::Reader::Stream)
+            filters = [obj.hash[:Filter]].flatten.compact
+            array += (filters - @algorithms)
+          end
+        end
+        array.uniq
+      end
+    end
+  end
+end

data/lib/preflight/rules/document_id.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+    class DocumentId
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        if ohash.trailer[:ID].nil?
+          ["Document ID missing"]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/preflight/rules/info_has_keys.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # ensure the info dict has the specified keys
+    class InfoHasKeys
+
+      def initialize(*keys)
+        @keys = keys.flatten
+      end
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        info = ohash.object(ohash.trailer[:Info])
+        missing = @keys - info.keys
+        missing.map { |key|
+          "Info dict missing required key #{key}"
+        }
+      end
+    end
+  end
+end

data/lib/preflight/rules/info_specifies_trapping.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+    class InfoSpecifiesTrapping
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        info = ohash.object(ohash.trailer[:Info])
+
+        if !info.has_key?(:Trapped)
+          [ "Info dict does not specify Trapped" ]
+        elsif info[:Trapped] != :True && info[:Trapped] != :False
+          [ "Trapped value of Info dict must be True or False" ]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/preflight/rules/match_info_entries.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+    class MatchInfoEntries
+
+      def initialize(matches = {})
+        @matches = matches
+      end
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        array = []
+        info = ohash.object(ohash.trailer[:Info])
+        @matches.each do |key, regexp|
+          if !info.has_key?(key)
+            array << "Info dict missing required key #{key}"
+          elsif !info[key].to_s.match(regexp)
+            array << "value of Info entry #{key} doesn't match (#{info[key]} != #{regexp})"
+          end
+        end
+        array
+      end
+    end
+  end
+end

data/lib/preflight/rules/max_version.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+    # ensure the PDF version of the file under review is not more recent
+    # than desired
+    class MaxVersion
+
+      def initialize(max_version)
+        @max_version = max_version.to_f
+      end
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        if ohash.pdf_version > @max_version
+          ["PDF version should be #{@max_version} or lower (value: #{ohash.pdf_version})"]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/preflight/rules/min_ppi.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # For high quality prints, you generally want raster images to be
+    # AT LEAST 300 points-per-inch (ppi). 600 is better, 1200 better again.
+    #
+    class MinPpi
+      include Preflight::Measurements
+
+      attr_reader :messages
+
+      def initialize(min_ppi)
+        @min_ppi = min_ppi.to_i
+        @messages = []
+        @last_matrix = []
+        @page_num = 0
+      end
+
+      def self.rule_type
+        :receiver
+      end
+
+      # store sample width and height for each image on the current page
+      #
+      def resource_xobject(label, stream)
+        return unless stream.hash[:Subtype] == :Image
+
+        @images[label] = [
+          stream.hash[:Width],
+          stream.hash[:Height]
+        ]
+      end
+
+      # track the most recent matrix transform.
+      #
+      # TODO: This needs to be smarter at tracking the graphics state stack
+      #
+      def concatenate_matrix(*args)
+        @last_matrix = args
+      end
+
+      # As each image is drawn on the canvas, determine the amount of device
+      # space it's being crammed into and therefore the PPI.
+      #
+      def invoke_xobject(label)
+        sample_w, sample_h = *@images[label]
+        device_w = pt2in(@last_matrix[0])
+        device_h = pt2in(@last_matrix[3])
+
+        horizontal_ppi = (sample_w / device_w).round(3)
+        vertical_ppi   = (sample_h / device_h).round(3)
+
+        if horizontal_ppi < @min_ppi || vertical_ppi < @min_ppi
+          @messages << "Image with low PPI/DPI on page #{@page_num} (h:#{horizontal_ppi} v:#{vertical_ppi})"
+        end
+      end
+
+      # start fresh on every page
+      #
+      def begin_page(hash = {})
+        @images = {}
+        @page_num += 1
+      end
+    end
+  end
+end

data/lib/preflight/rules/no_encryption.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+    class NoEncryption
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        if ohash.trailer[:Encrypt]
+          ["File is encrypted"]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/preflight/rules/no_font_subsets.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # check a file has no font subsets. Subsets are handy and valid
+    # in standards like PDFX/1a, but they make it hard to edit a
+    # file
+    #
+    class NoFontSubsets
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        array = []
+        ohash.each do |key, obj|
+          next unless obj.is_a?(::Hash) && obj[:Type] == :Font
+          if subset?(obj)
+            array << "Font #{obj[:BaseFont]} is a partial subset"
+          end
+        end
+        array
+      end
+
+      private
+
+      def subset?(font)
+        font[:BaseFont] && font[:BaseFont].match(/.+\+.+/)
+      end
+    end
+  end
+end

data/lib/preflight/rules/no_proprietary_fonts.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+
+require 'ttfunk'
+
+module Preflight
+  module Rules
+
+    # check a file has no proprietary fonts. They look nice, but we can't
+    # print the damn things.
+    #
+    class NoProprietaryFonts
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        array = []
+        ohash.each do |key, obj|
+          next unless obj.is_a?(::Hash) && obj[:Type] == :Font
+          if proprietary?(ohash, obj[:FontDescriptor])
+            array << "Font #{obj[:BaseFont]} is proprietary"
+          end
+        end
+        array
+      end
+
+      private
+
+      def proprietary?(ohash, descriptor)
+        descriptor = ohash.object(descriptor)
+
+        return false if descriptor.nil?
+        raise ArgumentError, 'expected a FontDescriptor hash' unless descriptor[:Type] == :FontDescriptor
+
+        if descriptor.has_key?(:FontFile)
+          # TODO embedded type 1 font
+          false
+        elsif descriptor.has_key?(:FontFile2) && ttf_proprietary?(ohash, descriptor[:FontFile2])
+          true
+        else
+          false
+        end
+      end
+
+      def ttf_proprietary?(ohash, font_file)
+        font_file = ohash.object(font_file)
+        ttf = TTFunk::File.new(font_file.unfiltered_data)
+        #puts ttf.name.strings
+        false
+      end
+    end
+  end
+end

data/lib/preflight/rules/only_embedded_fonts.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # check a file only uses embedded fonts
+    #
+    class OnlyEmbeddedFonts
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        array = []
+        ohash.each do |key, obj|
+          next unless obj.is_a?(::Hash) && obj[:Type] == :Font
+          if !embedded?(ohash, obj)
+            array << "Font #{obj[:BaseFont]} is not embedded"
+          end
+        end
+        array
+      end
+
+      private
+
+      def embedded?(ohash, font)
+        if font.has_key?(:FontDescriptor)
+          descriptor = ohash.object(font[:FontDescriptor])
+          descriptor.has_key?(:FontFile) || descriptor.has_key?(:FontFile2) || descriptor.has_key?(:FontFile3)
+        elsif font[:Subtype] == :Type0
+          descendants = ohash.object(font[:DescendantFonts])
+          descendants.all? { |f|
+            f = ohash.object(f)
+            embedded?(ohash, f)
+          }
+        else
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/preflight/rules/print_boxes.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # For PDFX/1a, every page must have MediaBox, plus either ArtBox or
+    # TrimBox
+    #
+    class PrintBoxes
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+        @page_num = 0
+      end
+
+      def self.rule_type
+        :receiver
+      end
+
+      def begin_page(hash = {})
+        @page_num += 1
+
+        if hash[:MediaBox].nil?
+          @messages << "every page must have a MediaBox (page #{@page_num})"
+        elsif hash[:ArtBox].nil? && hash[:TrimBox].nil?
+          @messages << "every page must have either an ArtBox or a TrimBox (page #{@page_num})"
+        elsif hash[:ArtBox] && hash[:TrimBox]
+          @messages << "no page can have both ArtBox and TrimBox - TrimBox is preferred (page #{@page_num})"
+        end
+      end
+    end
+  end
+end

data/lib/preflight/rules/root_has_keys.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # ensure the root dict has the specified keys
+    class RootHasKeys
+
+      def initialize(*keys)
+        @keys = keys.flatten
+      end
+
+      def self.rule_type
+        :hash
+      end
+
+      def messages(ohash)
+        root = ohash.object(ohash.trailer[:Root])
+        missing = @keys - root.keys
+        missing.map { |key|
+          "Root dict missing required key #{key}"
+        }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: preflight
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Healy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pdf-reader
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: roodi
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id004
+description: Provides a programatic way to check a PDF file conforms to standards like PDF-X/1a
+email: 
+- james@yob.id.au
+executables: 
+- is_pdfx_1a
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/preflight/profiles/pdfx1a.rb
+- lib/preflight/profiles/pdfa1a.rb
+- lib/preflight/profile.rb
+- lib/preflight/rules/root_has_keys.rb
+- lib/preflight/rules/min_ppi.rb
+- lib/preflight/rules/print_boxes.rb
+- lib/preflight/rules/info_specifies_trapping.rb
+- lib/preflight/rules/only_embedded_fonts.rb
+- lib/preflight/rules/compression_algorithms.rb
+- lib/preflight/rules/no_encryption.rb
+- lib/preflight/rules/no_font_subsets.rb
+- lib/preflight/rules/match_info_entries.rb
+- lib/preflight/rules/max_version.rb
+- lib/preflight/rules/no_proprietary_fonts.rb
+- lib/preflight/rules/info_has_keys.rb
+- lib/preflight/rules/document_id.rb
+- lib/preflight/rules/box_nesting.rb
+- lib/preflight/measurements.rb
+- lib/preflight/rules.rb
+- lib/preflight/profiles.rb
+- lib/preflight.rb
+- bin/is_pdfx_1a
+- README.rdoc
+- CHANGELOG
+has_rdoc: true
+homepage: http://github.com/yob/pdf-preflight
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- PDF::Preflight
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 2
+      version: 1.3.2
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Check PDF files conform to various standards
+test_files: []
+