preflight 0.1.1 → 0.2.0

data/lib/preflight/rules/no_rgb.rb

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+require 'forwardable'
+
+module Preflight
+  module Rules
+
+    # Some print workflows forbid the use of RGB colour.
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::NoRgb
+    #   end
+    #
+    class NoRgb
+      extend  Forwardable
+
+      # Graphics State Operators
+      def_delegators :@state, :save_graphics_state, :restore_graphics_state
+
+      # Matrix Operators
+      def_delegators :@state, :concatenate_matrix
+
+      attr_reader :issues
+
+      # we're about to start a new page, reset state
+      #
+      def page=(page)
+        @page   = page
+        @state  = PDF::Reader::PageState.new(page)
+        @issues = []
+        @resource_labels_seen = []
+      end
+
+      # descend into nested form xobjects
+      #
+      def invoke_xobject(label)
+        @state.invoke_xobject(label) do |xobj|
+          case xobj
+          when PDF::Reader::FormXObject then
+            xobj.walk(self)
+          when PDF::Reader::Stream then
+            check_xobject(xobj)
+          end
+        end
+      end
+
+      def set_rgb_color_for_stroking(r, g, b)
+        rgb_detected(r, g, b)
+      end
+
+      def set_rgb_color_for_nonstroking(r, g, b)
+        rgb_detected(r, g, b)
+      end
+
+      def set_stroke_color_space(label)
+        check_color_space(label)
+      end
+
+      def set_nonstroke_color_space(label)
+        check_color_space(label)
+      end
+
+      private
+
+      def color_space_is_rgb?(cs)
+        case cs
+        when Symbol then cs == :DeviceRGB
+        when Array  then
+          cs[2] == :DeviceRGB
+        else
+          false
+        end
+      end
+
+      def check_color_space(label)
+        return if @resource_labels_seen.include?(label)
+
+        if color_space_is_rgb?(@state.find_color_space(label))
+          @issues << Issue.new("RGB color detected", self, :page  => @page.number)
+        end
+
+        @resource_labels_seen << label
+      end
+
+      def check_xobject(xobject)
+        cs = xobject.hash[:ColorSpace]
+        if cs == :DeviceRGB
+          @issues << Issue.new("RGB image detected", self, :page  => @page.number)
+        end
+      end
+
+      def rgb_detected(r, g, b)
+        @issues << Issue.new("RGB color detected", self, :page  => @page.number,
+                                                         :red   => r,
+                                                         :green => g,
+                                                         :blue  => b)
+      end
+
+      def deref(obj)
+        @page.objects.deref(obj)
+      end
+
+    end
+
+  end
+end

data/lib/preflight/rules/no_separation.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+require 'forwardable'
+
+module Preflight
+  module Rules
+
+    # Some print workflows forbid the use of Separation colours (like
+    # Pantones).
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::NoSeparation
+    #   end
+    #
+    class NoSeparation
+      extend  Forwardable
+
+      # Graphics State Operators
+      def_delegators :@state, :save_graphics_state, :restore_graphics_state
+
+      # Matrix Operators
+      def_delegators :@state, :concatenate_matrix
+
+      attr_reader :issues
+
+      # we're about to start a new page, reset state
+      #
+      def page=(page)
+        @page   = page
+        @state  = PDF::Reader::PageState.new(page)
+        @issues = []
+        @resource_labels_seen = []
+      end
+
+      # descend into nested form xobjects
+      #
+      def invoke_xobject(label)
+        @state.invoke_xobject(label) do |xobj|
+          case xobj
+          when PDF::Reader::FormXObject then
+            xobj.walk(self)
+          end
+        end
+      end
+
+      def set_stroke_color_space(label)
+        check_color_space(label)
+      end
+
+      def set_nonstroke_color_space(label)
+        check_color_space(label)
+      end
+
+      private
+
+      def separation_name(cs)
+        if cs.is_a?(Array) && cs[0] == :Separation
+          cs[1]
+        else
+          nil
+        end
+      end
+
+      def check_color_space(label)
+        return if @resource_labels_seen.include?(label)
+
+        spot_name = separation_name(@state.find_color_space(label))
+        if spot_name
+          @issues << Issue.new("Separation color detected #{spot_name}", self, :page => @page.number,
+                                                                               :name => spot_name)
+        end
+
+        @resource_labels_seen << label
+      end
+
+    end
+
+  end
+end

data/lib/preflight/rules/no_transparency.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+require 'forwardable'
+
+module Preflight
+  module Rules
+
+    # For some print workflows transparency is forbidden.
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::NoTransparency
+    #   end
+    #
+    class NoTransparency
+      include Preflight::Measurements
+      extend  Forwardable
+
+      # Graphics State Operators
+      def_delegators :@state, :save_graphics_state, :restore_graphics_state
+
+      # Matrix Operators
+      def_delegators :@state, :concatenate_matrix
+
+      attr_reader :issues
+
+      # we're about to start a new page, reset state
+      #
+      def page=(page)
+        @page   = page
+        @state  = PDF::Reader::PageState.new(page)
+        @issues = []
+      end
+
+      def invoke_xobject(label)
+        @state.invoke_xobject(label) do |xobj|
+          case xobj
+          when PDF::Reader::FormXObject then
+            detect_transparent_form(xobj)
+            xobj.walk(self)
+          else
+            # TODO. can other xobjects have transparency?
+          end
+        end
+      end
+
+      # As each xobject is drawn on the canvas, record if it's Group XObject
+      # with transparency
+      #
+      def detect_transparent_form(form)
+        xobject = form.xobject
+        group   = deref(xobject.hash[:Group])
+        stype   = deref(group[:S])            if group
+
+        if stype == :Transparency
+          bbox = xobject.hash[:BBox] || @page.attributes[:MediaBox]
+          bbox = translate_to_device_space(bbox)
+          @issues << Issue.new("Transparent xobject found", self, :page         => @page.number,
+                                                                  :top_left     => bbox[:tl],
+                                                                  :bottom_left  => bbox[:bl],
+                                                                  :bottom_right => bbox[:br],
+                                                                  :top_right    => bbox[:tr])
+        end
+      end
+
+      private
+
+      def translate_to_device_space(bbox)
+        bl_x, bl_y, tr_x, tr_y = *bbox
+        {
+          :tl => @state.ctm_transform(bl_x, tr_y),
+          :bl => @state.ctm_transform(bl_x, bl_y),
+          :br => @state.ctm_transform(tr_x, bl_y),
+          :tr => @state.ctm_transform(tr_x, tr_y)
+        }
+      end
+
+      def deref(obj)
+        @objects ? @objects.deref(obj) : obj
+      end
+
+    end
+
+  end
+end

data/lib/preflight/rules/only_embedded_fonts.rb

@@ -3,32 +3,46 @@
 module Preflight
   module Rules
 
-    # check a file only uses embedded fonts
+    # Check the target PDF only uses embedded fonts
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::OnlyEmbeddedFonts
+    #   end
     #
     class OnlyEmbeddedFonts
 
-      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"
+      attr_reader :issues
+
+      def page=(page)
+        @issues = []
+
+        page.fonts.each { |key, obj|
+          obj = page.objects.deref(obj)
+          if !embedded?(page.objects, obj)
+            @issues << Issue.new("Font not embedded", self, :base_font => obj[:BaseFont])
           end
-        end
-        array
+        }
       end
 
       private
 
-      def embedded?(ohash, font)
+      def embedded?(objects, font)
+        return true if font[:Subtype] == :Type3
+
         if font.has_key?(:FontDescriptor)
-          descriptor = ohash.object(font[:FontDescriptor])
+          descriptor = objects.deref(font[:FontDescriptor])
           descriptor.has_key?(:FontFile) || descriptor.has_key?(:FontFile2) || descriptor.has_key?(:FontFile3)
         elsif font[:Subtype] == :Type0
-          descendants = ohash.object(font[:DescendantFonts])
+          descendants = objects.deref(font[:DescendantFonts])
           descendants.all? { |f|
-            f = ohash.object(f)
-            embedded?(ohash, f)
+            f = objects.deref(f)
+            embedded?(objects, f)
           }
         else
           false

data/lib/preflight/rules/output_intent_for_pdfx.rb

@@ -3,15 +3,27 @@
 module Preflight
   module Rules
 
+    # Check the target PDF contains an output intent suitable for PDFX
+    #
+    # Arguments: none
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::OutputIntentForPdfx
+    #   end
+    #
     class OutputIntentForPdfx
 
-      def messages(ohash)
+      def check_hash(ohash)
         intents = output_intents(ohash).select { |dict|
           ohash.object(dict)[:S] == :GTS_PDFX
         }
 
         if intents.size != 1
-          ["There must be exactly 1 OutputIntent with a subtype of GTS_PDFX"]
+          [Issue.new("There must be exactly 1 OutputIntent with a subtype of GTS_PDFX", self)]
         else
           []
         end

data/lib/preflight/rules/page_box_height.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+module Preflight
+  module Rules
+
+    # Ensure the requested page box (MediaBox, TrimBox, etc) on every page has
+    # the requested height. Dimensions can be in points, mm or inches. Skips
+    # the page if the requested box isn't defined, it's up to other rules to
+    # check for the existence of the box.
+    #
+    # Arguments: the target page box, the target height and the the units
+    #
+    # Usage:
+    #
+    #   class MyPreflight
+    #     include Preflight::Profile
+    #
+    #     rule Preflight::Rules::PageBoxHeight, :MediaBox, 100, :mm
+    #     rule Preflight::Rules::PageBoxHeight, :TrimBox, 600, :pts
+    #     rule Preflight::Rules::PageBoxHeight, :CropBox, 5, :in
+    #     rule Preflight::Rules::PageBoxHeight, :MediaBox, 100..101, :mm
+    #     rule Preflight::Rules::PageBoxHeight, :TrimBox, 600..700, :pts
+    #     rule Preflight::Rules::PageBoxHeight, :CropBox, 5..6, :in
+    #   end
+    #
+    class PageBoxHeight
+      include Preflight::Measurements
+
+      attr_reader :issues
+
+      def initialize(box, height, units)
+        @box, @units = box, units
+        @orig_height = height
+        @height = case units
+                  when :mm then mm_to_points(height)
+                  when :in then inches_to_points(height)
+                  else
+                    points_to_points(height)
+                  end
+      end
+
+      def page=(page)
+        @issues = []
+        dict = page.attributes
+
+        if dict[@box]
+          box_height  = dict[@box][3] - dict[@box][1]
+
+          if !@height.include?(box_height)
+            @issues << Issue.new("#{@box} height must be #{@orig_height}#{@units}", self, :page   => page.number,
+                                                                                          :box    => @box,
+                                                                                          :height => @orig_height,
+                                                                                          :units  => @units)
+          end
+        end
+      end
+
+      private
+
+      def inches_to_points(height)
+        case height
+        when Numeric then Range.new(in2pt(height)-1, in2pt(height)+1)
+        when Range   then Range.new(in2pt(height.min), in2pt(height.max))
+        else
+          raise ArgumentError, "height must be a Numeric or Range object"
+        end
+      end
+
+      def mm_to_points(height)
+        case height
+        when Numeric then Range.new(mm2pt(height)-1, mm2pt(height)+1)
+        when Range   then Range.new(mm2pt(height.min), mm2pt(height.max))
+        else
+          raise ArgumentError, "height must be a Numeric or Range object"
+        end
+      end
+
+      def points_to_points(height)
+        case height
+        when Numeric then Range.new(height, height)
+        when Range   then height
+        else
+          raise ArgumentError, "height must be a Numeric or Range object"
+        end
+      end
+    end
+  end
+end