preflight 0.1.1 → 0.2.0

data/lib/preflight/rules/document_id.rb

@@ -2,11 +2,23 @@
 
 module Preflight
   module Rules
+    # check the file has a document ID
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::DocumentId
+    #   end
+    #
     class DocumentId
 
-      def messages(ohash)
+      def check_hash(ohash)
         if ohash.trailer[:ID].nil?
-          ["Document ID missing"]
+          [Issue.new("Document ID missing", self)]
         else
           []
         end

data/lib/preflight/rules/info_has_keys.rb

@@ -3,18 +3,30 @@
 module Preflight
   module Rules
 
-    # ensure the info dict has the specified keys
+    # Every PDF has an optional 'Info' dictionary. Check that the target file
+    # has certain keys
+    #
+    # Arguments: the required keys
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::InfoHasKeys, :Title, :CreationDate, :ModDate
+    #   end
+    #
     class InfoHasKeys
 
       def initialize(*keys)
         @keys = keys.flatten
       end
 
-      def messages(ohash)
+      def check_hash(ohash)
         info = ohash.object(ohash.trailer[:Info])
         missing = @keys - info.keys
         missing.map { |key|
-          "Info dict missing required key #{key}"
+          Issue.new("Info dict missing required key", self, :key => key)
         }
       end
     end

data/lib/preflight/rules/info_specifies_trapping.rb

@@ -2,15 +2,28 @@
 
 module Preflight
   module Rules
+    # Every PDF has an optional 'Info' dictionary. Check that the dictionary
+    # has a 'Trapped' entry that is set to True or False
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::InfoSpecifiesTrapping
+    #   end
+    #
     class InfoSpecifiesTrapping
 
-      def messages(ohash)
+      def check_hash(ohash)
         info = ohash.object(ohash.trailer[:Info])
 
         if !info.has_key?(:Trapped)
-          [ "Info dict does not specify Trapped" ]
+          [ Issue.new("Info dict does not specify Trapped", self) ]
         elsif info[:Trapped] != :True && info[:Trapped] != :False
-          [ "Trapped value of Info dict must be True or False" ]
+          [ Issue.new("Trapped value of Info dict must be True or False", self) ]
         else
           []
         end

data/lib/preflight/rules/match_info_entries.rb

@@ -2,20 +2,34 @@
 
 module Preflight
   module Rules
+    # Every PDF has an optional 'Info' dictionary. Check that the target file
+    # has certain keys and that the keys match a given regexp
+    #
+    # Arguments: the required keys
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::MatchInfoEntries, {:GTS_PDFXVersion => /\APDF\/X/}
+    #   end
+    #
     class MatchInfoEntries
 
       def initialize(matches = {})
         @matches = matches
       end
 
-      def messages(ohash)
+      def check_hash(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}"
+            array << Issue.new("Info dict missing required key", self, :key => key)
           elsif !info[key].to_s.match(regexp)
-            array << "value of Info entry #{key} doesn't match (#{info[key]} != #{regexp})"
+            array << Issue.new("value of Info entry #{key} doesn't match #{regexp}", self, :key    => key,
+                                                                                           :regexp => regexp)
           end
         end
         array

data/lib/preflight/rules/max_ink_density.rb

@@ -0,0 +1,69 @@
+# coding: utf-8
+
+require 'yaml'
+require 'matrix'
+
+module Preflight
+  module Rules
+
+    # Most CMYK printers will have a stated upper tolerance for ink density. If
+    # the total percentage of the 4 components (C, M, Y and K) is over that
+    # tolerance then the result can be unpredictable and often ugly.
+    #
+    # Use this rule to detect CMYK ink densities over a certain threshold.
+    #
+    # Arguments: the highest density that is Ok
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::MaxInkDensity, 300
+    #   end
+    #
+    # TODO:
+    #
+    # * check CMYK colours used as alternates in a separation color
+    # * check CMYK raster images
+    #
+    class MaxInkDensity
+
+      attr_reader :issues
+
+      def initialize(max_ink)
+        @max_ink = max_ink.to_i
+      end
+
+      # we're about to start a new page, reset state
+      #
+      def page=(page)
+        @issues = []
+        @page    = page
+        @objects = page.objects
+      end
+
+      def set_cmyk_color_for_nonstroking(c, m, y, k)
+        check_ink(c, m, y, k)
+      end
+
+      def set_cmyk_color_for_stroking(c, m, y, k)
+        check_ink(c, m, y, k)
+      end
+
+      private
+
+      def check_ink(c, m, y, k)
+        ink = (c + m + y + k) * 100.0
+        if ink > @max_ink && @issues.empty?
+          @issues << Issue.new("Ink density too high", self, :page    => @page.number,
+                                                             :cyan    => c,
+                                                             :magenta => m,
+                                                             :yellow  => y,
+                                                             :k       => k)
+        end
+      end
+    end
+
+  end
+end

data/lib/preflight/rules/max_version.rb

@@ -4,15 +4,27 @@ module Preflight
   module Rules
     # ensure the PDF version of the file under review is not more recent
     # than desired
+    #
+    # Arguments: the maximum version
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::MaxVersion, 1.4
+    #   end
+    #
     class MaxVersion
 
       def initialize(max_version)
         @max_version = max_version.to_f
       end
 
-      def messages(ohash)
+      def check_hash(ohash)
         if ohash.pdf_version > @max_version
-          ["PDF version should be #{@max_version} or lower (value: #{ohash.pdf_version})"]
+          [Issue.new("PDF version should be #{@max_version} or lower", self, :max_version     => @max_version,
+                                                                             :current_version => ohash.pdf_version)]
         else
           []
         end

data/lib/preflight/rules/mediabox_at_origin.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+require 'bigdecimal'
+
+module Preflight
+  module Rules
+
+    # Checks the MediaBox for every page is at 0,0. This isn't required by
+    # any standards but is good practice to ensure correct rendering with
+    # some applications.
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::MediaboxAtOrigin
+    #   end
+    #
+    class MediaboxAtOrigin
+
+      attr_reader :issues
+
+      def page=(page)
+        @issues = []
+        dict = page.attributes
+
+        if round_off(dict[:MediaBox][0,2]) != [0,0]
+          @issues << Issue.new("MediaBox must begin at 0,0", 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

data/lib/preflight/rules/min_bleed.rb

@@ -0,0 +1,171 @@
+# coding: utf-8
+
+require 'forwardable'
+require 'matrix'
+
+module Preflight
+  module Rules
+
+    # To print colour to the edge of the page you must print past the intended
+    # page edge and then trim the printed sheet. The printed area that will be
+    # trimmed is called bleed. Generally you will probably want 3-4mm of bleed.
+    #
+    # Arguments: the distance from the TrimBox within which objects MUST include bleed
+    #            the distance past the TrimBox that objects MUST bleed
+    #            the units (:pt, :mm, :in)
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::MinBleed, 1, 4, :mm
+    #     rule Preflight::Rules::MinBleed, 12, 50, :pt
+    #     rule Preflight::Rules::MinBleed, 0.1, 0.25, :in
+    #   end
+    #
+    class MinBleed
+      include Preflight::Measurements
+      extend  Forwardable
+
+      attr_reader :issues
+
+      # Graphics State Operators
+      def_delegators :@state, :save_graphics_state, :restore_graphics_state
+
+      # Matrix Operators
+      def_delegators :@state, :concatenate_matrix
+
+      def initialize(range, bleed, units)
+        @range, @bleed, @units = range, bleed, units
+      end
+
+      # we're about to start a new page, reset state
+      #
+      def page=(page)
+        @issues  = []
+        @page    = page
+        @state   = PDF::Reader::PageState.new(page)
+        @objects = page.objects
+
+        attrs = @page.attributes
+        box   = attrs[:TrimBox] || attrs[:ArtBox] || attrs[:MediaBox]
+        @warning_min_x = box[0] + to_points(@range, @units)
+        @warning_min_y = box[1] + to_points(@range, @units)
+        @warning_max_x = box[2] - to_points(@range, @units)
+        @warning_max_y = box[3] - to_points(@range, @units)
+        @error_min_x   = box[0] - to_points(@bleed, @units)
+        @error_min_y   = box[1] - to_points(@bleed, @units)
+        @error_max_x   = box[2] + to_points(@bleed, @units)
+        @error_max_y   = box[3] + to_points(@bleed, @units)
+      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)
+        @state.invoke_xobject(label) do |xobj|
+          case xobj
+          when PDF::Reader::FormXObject then
+            xobj.walk(self)
+          when PDF::Reader::Stream
+            invoke_image_xobject(xobj) if xobj.hash[:Subtype] == :Image
+          else
+            raise xobj.inspect
+          end
+        end
+      end
+
+      def append_rectangle(x1, y1, x2, y2)
+        @path ||= []
+        @path << @state.ctm_transform(x1, y1)
+        @path << @state.ctm_transform(x1, y2)
+        @path << @state.ctm_transform(x2, y1)
+        @path << @state.ctm_transform(x2, y2)
+      end
+
+      def fill_path_with_nonzero
+        @path ||= []
+        points = select_points_in_danger_zone(@path)
+
+        if points.size > 0
+          @issues << Issue.new("Filled object with insufficient bleed", self, :page        => @page.number,
+                                                                              :object_type => :filled_object,
+                                                                              :bleed       => @bleed,
+                                                                              :units       => @units)
+        end
+
+        @path = []
+      end
+      alias :fill_path_with_even_odd :fill_path_with_nonzero
+
+      def close_and_stroke_path
+        @path = []
+      end
+
+      def stroke_path
+        @path = []
+      end
+
+      def end_path
+        @path = []
+      end
+
+      private
+
+      def invoke_image_xobject(xobject)
+        return unless @page.attributes[:TrimBox] || @page.attributes[:ArtBox]
+
+        points = select_points_in_danger_zone(image_points)
+
+        if points.size > 0
+          @issues << Issue.new("Image with insufficient bleed", self, :page        => @page.number,
+                                                                      :object_type => :image,
+                                                                      :bleed       => @bleed,
+                                                                      :units       => @units)
+        end
+      end
+
+      def deref(obj)
+        @objects ? @objects.deref(obj) : obj
+      end
+
+      # convert value units to PDF points. units should be :mm, :in or :pt
+      #
+      def to_points(value, units)
+        case units
+        when :mm then mm2pt(value)
+        when :in then in2pt(value)
+        else
+          value
+        end
+      end
+
+      # return the co-ordinates for the 4 corners of an image according
+      # to the current CTM
+      #
+      def image_points
+        [
+          @state.ctm_transform(0, 0),
+          @state.ctm_transform(0, 1),
+          @state.ctm_transform(1, 0),
+          @state.ctm_transform(1, 1)
+        ]
+      end
+
+      # given an array of points, returns the subset of points (if any) that
+      # fall within the danger zone indicating they're close to the TrimBox
+      # without enough bleed
+      #
+      def select_points_in_danger_zone(points)
+        points.select { |p|
+          (p.first < @warning_min_x && p.first > @error_min_x) ||
+          (p.last < @warning_min_y  && p.last > @error_min_y) ||
+          (p.first > @warning_max_x && p.first < @error_max_x) ||
+          (p.last > @warning_max_x  && p.last < @error_max_y)
+        }
+      end
+
+    end
+  end
+end

data/lib/preflight/rules/min_ppi.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 
-require 'yaml'
 require 'matrix'
+require 'forwardable'
 
 module Preflight
   module Rules
@@ -9,160 +9,98 @@ module Preflight
     # For high quality prints, you generally want raster images to be
     # AT LEAST 300 points-per-inch (ppi). 600 is better, 1200 better again.
     #
+    # Arguments: the lowest PPI that is ok
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::MinPpi, 300
+    #   end
+    #
     class MinPpi
       include Preflight::Measurements
+      extend  Forwardable
+
+      attr_reader :issues
 
-      DEFAULT_GRAPHICS_STATE = {
-        :ctm => Matrix.identity(3)
-      }
+      # Graphics State Operators
+      def_delegators :@state, :save_graphics_state, :restore_graphics_state
 
-      attr_reader :messages
+      # Matrix Operators
+      def_delegators :@state, :concatenate_matrix
 
       def initialize(min_ppi)
         @min_ppi = min_ppi.to_i
-        @messages = []
-        @page_num = 0
-      end
-
-      def save_graphics_state
-        @stack.push clone_state
-      end
-
-      def restore_graphics_state
-        @stack.pop
-      end
-
-      def state
-        @stack.last
       end
 
-      # store sample width and height for each image on the current page
+      # we're about to start a new page, reset state
       #
-      def resource_xobject(label, stream)
-        return unless stream.hash[:Subtype] == :Image
-
-        @images[label] = [
-          stream.hash[:Width],
-          stream.hash[:Height]
-        ]
-      end
-
-      # update the current transformation matrix.
-      #
-      # If the CTM is currently undefined, just store the new values.
-      #
-      # If there's an existing CTM, then multiple the existing matrix
-      # with the new matrix to form the updated matrix.
-      #
-      def concatenate_matrix(*args)
-        transform = Matrix[
-          [args[0], args[1], 0],
-          [args[2], args[3], 0],
-          [args[4], args[5], 1]
-        ]
-        if state[:ctm]
-          state[:ctm] = transform * state[:ctm]
-        else
-          state[:ctm] = transform
-        end
+      def page=(page)
+        @page   = page
+        @state  = PDF::Reader::PageState.new(page)
+        @issues = []
       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)
-        return unless @images[label]
+        @state.invoke_xobject(label) do |xobj|
+          case xobj
+          when PDF::Reader::FormXObject then
+            xobj.walk(self)
+          when PDF::Reader::Stream
+            invoke_image_xobject(xobj) if xobj.hash[:Subtype] == :Image
+          end
+        end
+      end
+
+      private
 
-        sample_w, sample_h = *@images[label]
+      def invoke_image_xobject(xobject)
+        sample_w = deref(xobject.hash[:Width])  || 0
+        sample_h = deref(xobject.hash[:Height]) || 0
         device_w = pt2in(image_width)
         device_h = pt2in(image_height)
 
-        horizontal_ppi = (sample_w / device_w).round(3)
-        vertical_ppi   = (sample_h / device_h).round(3)
+        horizontal_ppi = BigDecimal.new((sample_w / device_w).to_s).round(3)
+        vertical_ppi   = BigDecimal.new((sample_h / device_h).to_s).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})"
+          @issues << Issue.new("Image with low PPI/DPI", self, :page           => @page.number,
+                                                               :horizontal_ppi => horizontal_ppi,
+                                                               :vertical_ppi   => vertical_ppi,
+                                                               :top_left       => @state.ctm_transform(0, 1),
+                                                               :bottom_left    => @state.ctm_transform(0, 0),
+                                                               :bottom_right   => @state.ctm_transform(1, 0),
+                                                               :top_right      => @state.ctm_transform(1, 1))
         end
       end
 
-      # start fresh on every page
-      #
-      def begin_page(hash = {})
-        @images = {}
-        @page_num += 1
-        @stack = [DEFAULT_GRAPHICS_STATE]
-      end
-
-      private
-
-      # return the current transformation matrix
-      #
-      def ctm
-        state[:ctm]
-      end
-
-      # transform x and y co-ordinates from the current user space to the
-      # underlying device space.
-      #
-      def transform(point, z = 1)
-        Point.new(
-          (ctm[0,0] * point.x) + (ctm[1,0] * point.y) + (ctm[2,0] * z),
-          (ctm[0,1] * point.x) + (ctm[1,1] * point.y) + (ctm[2,1] * z)
-        )
+      def deref(obj)
+        @objects ? @objects.deref(obj) : obj
       end
 
       # return a height of an image in the current device space. Auto
       # handles the translation from image space to device space.
       #
       def image_height
-        bottom_left = transform(Point.new(0, 0))
-        top_left    = transform(Point.new(0, 1))
+        bottom_left = @state.ctm_transform(0, 0)
+        top_left    = @state.ctm_transform(0, 1)
 
-        bottom_left.distance(top_left)
+        Math.hypot(bottom_left.first-top_left.first, bottom_left.last-top_left.last)
       end
 
       # return a width of an image in the current device space. Auto
       # handles the translation from image space to device space.
       #
       def image_width
-        bottom_left  = transform(Point.new(0, 0))
-        bottom_right = transform(Point.new(1, 0))
-
-        bottom_left.distance(bottom_right)
-      end
+        bottom_left  = @state.ctm_transform(0, 0)
+        bottom_right = @state.ctm_transform(1, 0)
 
-      # when save_graphics_state is called, we need to push a new copy of the
-      # current state onto the stack. That way any modifications to the state
-      # will be undone once restore_graphics_state is called.
-      #
-      # This returns a deep clone of the current state, ensuring changes are
-      # keep separate from earlier states.
-      #
-      # YAML is used to round-trip the state through a string to easily perform
-      # the deep clone. Kinda hacky, but effective.
-      #
-      def clone_state
-        if @stack.empty?
-          {}
-        else
-          yaml_state = YAML.dump(@stack.last)
-          YAML.load(yaml_state)
-        end
-      end
-
-      # private class for representing points on a cartesian plain. Used
-      # to simplify maths in the MinPpi class.
-      #
-      class Point
-        attr_reader :x, :y
-
-        def initialize(x,y)
-          @x, @y = x,y
-        end
-
-        def distance(point)
-          Math.hypot(point.x - x, point.y - y)
-        end
+        Math.hypot(bottom_left.first-bottom_right.first, bottom_left.last-bottom_right.last)
       end
 
     end