jpdfer 0.3.1-java

data/README.rdoc

@@ -0,0 +1,14 @@
+= jpdfer
+
+JRuby gem to wrap iText, the PDF manipulation java libraries. Allows
+you to:
+
+
+* Inspect PDF forms
+* Write to form fields
+* Flatten PDF forms
+
+
+= TODO
+
+* Add checkbox field to simple_form.pdf

data/lib/jpdfer/key_store.rb

@@ -0,0 +1,23 @@
+module Jpdfer
+
+  class KeyStore
+    JavaFileInputStream = java.io.FileInputStream
+    JavaKeyStore = java.security.KeyStore
+    JavaString = java.lang.String
+
+    def initialize(keystore_path, _alias, password)
+      @alias, @password = _alias, password
+      @keystore = JavaKeyStore::getInstance(JavaKeyStore::getDefaultType())
+      @keystore.load(JavaFileInputStream.new(keystore_path), JavaString.new(@password).toCharArray)
+    end
+
+    def private_key
+      @keystore.getKey(@alias, java.lang.String.new(@password).toCharArray)
+    end
+
+    def certificate_chain
+      @keystore.getCertificateChain(@alias)
+    end
+  end
+
+end

data/lib/jpdfer/page_sizes.rb

@@ -0,0 +1,62 @@
+module Jpdfer
+  include_package "com.itextpdf.text"
+
+  def self.dimension_array(page_size)
+    [page_size.width, page_size.height]
+  end
+
+  PAGE_SIZES = {
+    dimension_array(PageSize::_11X17) => :'11x17',
+    dimension_array(PageSize::A0) => :a0,
+    dimension_array(PageSize::A1) => :a1,
+    dimension_array(PageSize::A10) => :a10,
+    dimension_array(PageSize::A2) => :a2,
+    dimension_array(PageSize::A3) => :a3,
+    dimension_array(PageSize::A4) => :a4,
+    dimension_array(PageSize::A5) => :a5,
+    dimension_array(PageSize::A6) => :a6,
+    dimension_array(PageSize::A7) => :a7,
+    dimension_array(PageSize::A8) => :a8,
+    dimension_array(PageSize::A9) => :a9,
+    dimension_array(PageSize::ARCH_A) => :arch_a,
+    dimension_array(PageSize::ARCH_B) => :arch_b,
+    dimension_array(PageSize::ARCH_C) => :arch_c,
+    dimension_array(PageSize::ARCH_D) => :arch_d,
+    dimension_array(PageSize::ARCH_E) => :arch_e,
+    dimension_array(PageSize::B0) => :b0,
+    dimension_array(PageSize::B1) => :b1,
+    dimension_array(PageSize::B10) => :b10,
+    dimension_array(PageSize::B2) => :b2,
+    dimension_array(PageSize::B3) => :b3,
+    dimension_array(PageSize::B4) => :b4,
+    dimension_array(PageSize::B5) => :b5,
+    dimension_array(PageSize::B6) => :b6,
+    dimension_array(PageSize::B7) => :b7,
+    dimension_array(PageSize::B8) => :b8,
+    dimension_array(PageSize::B9) => :b9,
+    dimension_array(PageSize::CROWN_OCTAVO) => :crown_octavo,
+    dimension_array(PageSize::CROWN_QUARTO) => :crown_quarto,
+    dimension_array(PageSize::DEMY_OCTAVO) => :demy_octavo,
+    dimension_array(PageSize::DEMY_QUARTO) => :demy_quarto,
+    dimension_array(PageSize::EXECUTIVE) => :executive,
+    dimension_array(PageSize::FLSA) => :flsa,
+    dimension_array(PageSize::FLSE) => :flse,
+    dimension_array(PageSize::HALFLETTER) => :halfletter,
+    dimension_array(PageSize::ID_1) => :id_1,
+    dimension_array(PageSize::ID_2) => :id_2,
+    dimension_array(PageSize::ID_3) => :id_3,
+    dimension_array(PageSize::LARGE_CROWN_OCTAVO) => :large_crown_octavo,
+    dimension_array(PageSize::LARGE_CROWN_QUARTO) => :large_crown_quarto,
+    dimension_array(PageSize::LEDGER) => :ledger,
+    dimension_array(PageSize::LEGAL) => :legal,
+    dimension_array(PageSize::LETTER) => :letter,
+    dimension_array(PageSize::NOTE) => :note,
+    dimension_array(PageSize::PENGUIN_LARGE_PAPERBACK) => :penguin_large_paperback,
+    dimension_array(PageSize::PENGUIN_SMALL_PAPERBACK) => :penguin_small_paperback,
+    dimension_array(PageSize::POSTCARD) => :postcard,
+    dimension_array(PageSize::ROYAL_OCTAVO) => :royal_octavo,
+    dimension_array(PageSize::ROYAL_QUARTO) => :royal_quarto,
+    dimension_array(PageSize::SMALL_PAPERBACK) => :small_paperback,
+    dimension_array(PageSize::TABLOID) => :tabloid
+  }
+end

data/lib/jpdfer/pdf.rb

@@ -0,0 +1,246 @@
+require 'jpdfer/page_sizes'
+# High-level/convenience wrapper class for a PDF document.
+
+module Jpdfer
+
+  # PDF Document with a form that can be read, filled, and saved.
+  class Pdf
+    class NonexistentFieldError < Exception; end
+    class ReadOnlyError < Exception; end
+    include_class Java::com.itextpdf.text.Image
+    include_class Java::java.net.URL
+    include_package "com.itextpdf.text.pdf"
+    include_package "com.itextpdf.text.xml.xmp"
+
+    def self.create_flatten_fields_xml(fields)
+      schema = DublinCoreSchema.new
+      schema.addDescription(JSON({'jpdfer_flattened_fields' => fields}))
+      metaout = StringIO.new
+      xmpwriter = XmpWriter.new(metaout.to_outputstream)
+      xmpwriter.addRdfDescription(schema)
+      xmpwriter.close
+      metaout.string
+    end
+
+    def self.description_from_metadata_xml(metadata_string)
+      metadata_string.gsub!(/<\?.*?\?>/, '')
+      namespaces = {
+        "xmlns:x"   => "adobe:ns:meta/",
+        "xmlns:rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+        "xmlns:dc"  => "http://purl.org/dc/elements/1.1/"
+      }
+      root_node = Nokogiri::XML.parse(metadata_string)
+      descriptions = root_node.xpath('.//dc:description//rdf:li/text()', namespaces)
+      descriptions.count > 0 ? descriptions.first.text : ""
+    end
+
+    def self.open(pdf_path, save_path, options={})
+      flatten = options.delete(:flatten)
+      pdf = self.new(pdf_path, options)
+      if block_given?
+        yield pdf
+        pdf.save_as(save_path, flatten)
+      else
+        pdf
+      end
+    end
+
+    # Currently the only option is :keystore
+    def initialize(path, options = {})
+      @data = File.read(path)
+      @output_buffer = StringIO.new
+      reader = PdfReader.new(@data.to_java_bytes)
+      @stamper = create_stamper(reader, options[:keystore])
+      @saved = false
+    end
+
+    # helper method for initialize not ment to be used publicly
+    def create_stamper(reader, keystore = nil)
+      if keystore
+        stamper = PdfStamper.createSignature(reader, @output_buffer.to_outputstream, 0)
+        key, certificate_chain = keystore.private_key, keystore.certificate_chain
+        # TODO: Should not always be self-signed
+        signature_type = Pdf::PdfSignatureAppearance::SELF_SIGNED
+        stamper.getSignatureAppearance.setCrypto(key, certificate_chain, nil, signature_type)
+      else
+        stamper = PdfStamper.new(reader, @output_buffer.to_outputstream)
+      end
+      stamper
+    end
+
+    # Writes PDF to +path+. If +flatten+ is true, also flattens the form
+    # so that the form is printed on the PDF document but the form is no
+    # longer editable.
+    #
+    # Once a this has been called the PDF becomes read-only and any
+    # subsequent calls to +save_as+, +set_field+, or +set_fields+
+    # will raise an ReadOnlyError.
+    #
+    # save_as returns *UNTESTED* if the PDF form is not valid
+    def save_as(path, flatten=false)
+      raise ReadOnlyError.new("Cannot save a previously saved pdf") if @saved
+      @saved = true
+      if flatten
+        metadata = self.class.create_flatten_fields_xml(fields)
+        @stamper.setXmpMetadata metadata.to_java_bytes
+      end
+      @stamper.setFormFlattening(flatten)
+      @stamper.close
+      File.open(path, 'wb') do |file|
+        file.write(@output_buffer.string)
+      end
+    end
+
+    # Returns the page size of the pdf as [width (Float), height (Float)]
+    def page_size
+      page_size = @stamper.reader.crop_box(1)
+      if @stamper.reader.page_rotation(1) % 180 == 0
+        [page_size.width, page_size.height]
+      else
+        [page_size.height, page_size.width]
+      end
+    end
+
+    # Returns the page type of the pdf or :unknown
+    # See Jpdfer::PAGES_SIZES
+    def page_type
+      PAGE_SIZES.fetch(page_size, :unknown)
+    end
+
+    # Returns fields defined in this PDF form and their values, if any.
+    # fields returns an empty hash if PDF document does not contain a form
+    def fields
+      form = @stamper.getAcroFields
+      h = {}
+      form.getFields.each_pair do |name, value|
+        h[name.to_sym] = form.getField(name)
+      end
+      h
+    end
+
+    # Returns value of named field.
+    #
+    # Raises Pdf::NonexistentFieldError if field does not exist.
+    # +name+:: Symbol name of field to retrieve
+    def get_field(name)
+      raise NonexistentFieldError.new("'#{name}' field does not exist in form") unless has_field?(name)
+      @stamper.getAcroFields.getField(name.to_s)
+    end
+
+    # Sets named field. set_field returns value set.
+    #
+    # Raises Pdf::NonexistentFieldError if field does not exist.
+    # +name+: Symbol naming the field to write
+    def set_field(name, value)
+      raise ReadOnlyError.new('Previously saved pdfs are read-only') if @saved
+      name = name.to_sym
+      raise NonexistentFieldError.new("'#{name}' field does not exist in form") unless has_field?(name)
+      @stamper.getAcroFields.setField(name.to_s, value.to_s)
+      value
+    end
+
+    # Sets many fields at once. Returns the hash of fields set (should
+    # always be equal to given set of fields).
+    #
+    # Raises Pdf::NonexistentFieldError if any field does not exist.
+    # +fields+:: A hash of :key => "value" pairs.
+    def set_fields(fields)
+      fields.each_pair do |name, value|
+        set_field(name, value)
+      end
+      fields
+    end
+
+    # true if field +name+ exists in form
+    #
+    # +name+:: Field name as Symbol (or String)
+    def has_field?(name)
+      fields.key?(name.to_sym)
+    end
+
+    # true if the receiving Pdf instance has a form
+    def has_form?
+      @stamper.getAcroFields.getFields.size > 0
+    end
+
+    # Returns field names and values that were written to a
+    # form in this pdf before flattening.
+    # Returns an empty hash if there are not any.
+    def flattened_fields
+      reader = @stamper.reader
+      metadata_string = String.from_java_bytes reader.getMetadata
+      description_text = self.class.description_from_metadata_xml(metadata_string)
+      begin
+        metadata = JSON(description_text)
+        _flattened_fields = metadata.key?('jpdfer_flattened_fields') ? metadata['jpdfer_flattened_fields'] : {}
+      rescue JSON::ParserError
+        _flattened_fields = {}
+      end
+      h = {}
+      _flattened_fields.each_pair do |name, value|
+        h[name.to_sym] = value
+      end
+      h
+    end
+
+    # true if the receiving Pdf instance was previously flattened with jpdfer
+    def has_flattened_fields?
+      flattened_fields.size > 0 ? true : false
+    end
+
+    # Returns the certification level of the pdf
+    def certification_level
+      case @stamper.reader.getCertificationLevel
+      when PdfSignatureAppearance::CERTIFIED_FORM_FILLING
+        level = :form_filling
+      when PdfSignatureAppearance::CERTIFIED_FORM_FILLING_AND_ANNOTATIONS
+        level = :form_filling_and_annotations
+      when PdfSignatureAppearance::CERTIFIED_NO_CHANGES_ALLOWED
+        level = :no_changes_allowed
+      when PdfSignatureAppearance::NOT_CERTIFIED
+        level = :not_certified
+      end
+      level
+    end
+
+    # Set the certification level on a pdf initialized with an optional keystore
+    #
+    # *level* must be one of :form_filling, :form_filling_and_annotations,
+    # :no_changes_allowed, :not_certified
+    def set_certification_level(level)
+      case level
+      when :form_filling
+        certification_level = PdfSignatureAppearance::CERTIFIED_FORM_FILLING
+      when :form_filling_and_annotations
+        certification_level = PdfSignatureAppearance::CERTIFIED_FORM_FILLING_AND_ANNOTATIONS
+      when :no_changes_allowed
+        certification_level = PdfSignatureAppearance::CERTIFIED_NO_CHANGES_ALLOWED
+      when :not_certified
+        level = PdfSignatureAppearance::NOT_CERTIFIED
+      end
+      @stamper.getSignatureAppearance.setCertificationLevel(certification_level)
+    end
+
+    # Sets the reason for the signature on the pdf
+    def set_signature_reason(reason)
+      @stamper.getSignatureAppearance.setReason(reason)
+    end
+
+    # Sets the location of the signature on the pdf
+    def set_signature_location(location)
+      @stamper.getSignatureAppearance.setLocation(location)
+    end
+
+    # Adds the image at +image_path+ to the given +page+, at coordinates +x+ and +y+
+    def add_image(image_path, page, x, y, scale=1.0)
+      raise ReadOnlyError.new('Previously saved pdfs are read-only') if @saved
+      canvas = @stamper.getOverContent(page)
+      image = Image.getInstance(image_path)
+      image.setAbsolutePosition(x, y)
+      image.scalePercent(scale * 100)
+      canvas.addImage(image, false)
+    end
+
+  end
+
+end

data/lib/jpdfer/version.rb

@@ -0,0 +1,3 @@
+module Jpdfer
+  VERSION = "0.3.1"
+end

data/lib/jpdfer.rb

@@ -0,0 +1,17 @@
+require 'java'
+require 'stringio'
+require 'json'
+require 'nokogiri'
+
+module Jpdfer
+  ROOT = File.expand_path('..', File.dirname(__FILE__))
+end
+
+require File.expand_path('jars/itextpdf-5.1.1.jar', Jpdfer::ROOT)
+require File.expand_path('jars/bcprov-jdk16-146.jar', Jpdfer::ROOT)
+require File.expand_path('jars/bctsp-jdk16-146.jar', Jpdfer::ROOT)
+require File.expand_path('jars/bcmail-jdk16-146.jar', Jpdfer::ROOT)
+
+require 'jpdfer/pdf'
+require 'jpdfer/key_store'
+require 'jpdfer/version'

data/spec/acceptance/jpdfer/pdf_acceptance_spec.rb

@@ -0,0 +1,387 @@
+require 'spec_helper'
+
+module Jpdfer
+
+describe "Pdf Acceptance" do
+  before(:each) do
+    @data_path = File.join(ROOT, 'spec', 'data')
+    @pdf_path = File.join(@data_path, 'simple_form.pdf')
+    @pdf = Pdf.new(@pdf_path)
+    @unfilled_fields = {
+      :important_field => '',
+      :unimportant_field => '',
+      :semiimportant_field => '',
+      :tuesday_field => '',
+      :must_not_be_left_blank_field => ''
+    }
+    @filled_fields = {
+      :important_field => "I am important",
+      :unimportant_field => 'I am unimportant',
+      :semiimportant_field => 'I am confused',
+      :tuesday_field => 'Is it Tuesday already?',
+      :must_not_be_left_blank_field => 'NOT BLANK'
+    }
+  end
+
+  describe '.new' do
+    it 'should create new pdf' do
+      @pdf.should_not be_nil
+    end
+
+    describe 'given missing file' do
+      it 'should raise Errno::ENOENT (File Not Found)' do
+        lambda { Pdf.new('derp.pdf') }.should raise_error(Errno::ENOENT)
+      end
+    end
+
+    describe 'given an optional keystore' do
+      describe 'when Pdf is configured' do
+        before(:each) do
+          @keystore = KeyStore.new(
+            File.join(@data_path, 'keystore.ks'),
+            'jpdfer',
+            'durrderp'
+          )
+          @pdf = Pdf.new(@pdf_path, :keystore => @keystore)
+          @signed_pdf_path = File.join(@data_path, 'new_signed.pdf')
+        end
+
+        after(:each) do
+          FileUtils.rm_f(@signed_pdf_path)
+        end
+
+        it 'should create a signed pdf if saved' do
+          @pdf.save_as(@signed_pdf_path)
+          File.open(@signed_pdf_path) do |file|
+            data = file.read
+            data['Scott Nielsen'].should == 'Scott Nielsen'
+            data['Saxton Horne'].should == 'Saxton Horne'
+          end
+        end
+
+        describe '#set_certification_level' do
+          it 'should have the given certification level when saved' do
+            @pdf.set_certification_level(:no_changes_allowed)
+            @pdf.save_as(@signed_pdf_path)
+            @pdf = Pdf.new(@signed_pdf_path)
+            @pdf.certification_level.should == :no_changes_allowed
+          end
+        end
+
+        # TODO: I would like to add this functionality but havn't researched the java
+        # KeyStore and encryption classes enough yet
+        #
+        # describe 'given a pdf signed with the private_key and certificate' do
+        #   before(:each) do
+        #     pdf_path = File.join(@data_path, 'simple_form_flattened_signed.pdf')
+        #     @pdf = Pdf.new(pdf_path, :keystore => @keystore)
+        #   end
+
+        #   describe '#signed?' do
+        #     it 'should be true' do
+        #       @pdf.should be_signed
+        #     end
+        #   end
+        # end
+
+        # describe 'given a pdf not signed with the private_key and certificate' do
+        #   before(:each) do
+        #     pdf_path = File.join(@data_path, 'simple_form_signed_by_someone_else.pdf')
+        #     @pdf = Pdf.new(pdf_path, :keystore => @keystore)
+        #   end
+
+        #   describe '#signed?' do
+        #     it 'should be false' do
+        #       @pdf.should_not be_signed
+        #     end
+        #   end
+        # end
+      end
+    end
+  end
+
+  describe '.open' do
+    before(:each) do
+      @save_path = File.join(@data_path, 'new_pdf.pdf')
+    end
+
+    after(:each) do
+      FileUtils.rm_f(@save_path)
+    end
+
+    it 'should instaniate a new pdf a pass it to the block and then save it' do
+      Pdf.open(@pdf_path, @save_path) do |pdf|
+        pdf.set_fields(@filled_fields)
+      end
+      new_pdf = Pdf.new(@save_path)
+      new_pdf.fields.should == @filled_fields
+    end
+
+    describe 'given the flatten option' do
+      it 'should be saved with the flatten option' do
+        Pdf.open(@pdf_path, @save_path, :flatten => true) do |pdf|
+          pdf.set_fields(@filled_fields)
+        end
+        new_pdf = Pdf.new(@save_path)
+        new_pdf.flattened_fields.should == @filled_fields
+      end
+    end
+  end
+
+  describe '#page_size' do
+    it 'should return the page size as an array of floats' do
+      @pdf.page_size.should == [612.0, 792.0]
+    end
+  end
+
+  describe '#page_type' do
+    it 'should return the page type if it exists' do
+      @pdf.page_type.should == :letter
+    end
+  end
+
+  describe '#certification_level' do
+    it 'should return nil for an unsigned pdf' do
+      @pdf.certification_level.should == :not_certified
+    end
+
+    describe 'called on a signed pdf' do
+      before(:each) do
+        @pdf = Pdf.new(File.join(@data_path, 'simple_form_flattened_signed.pdf'))
+      end
+
+      it 'it should return the certification level' do
+        @pdf.certification_level.should == :no_changes_allowed
+      end
+    end
+  end
+
+  describe '#fields' do
+    it 'should return a hash of field name value pairs' do
+      @pdf.fields.should == @unfilled_fields
+    end
+  end
+
+  describe '#get_field' do
+    it 'should return the field value' do
+      @pdf.get_field(:important_field).should == ""
+    end
+
+    describe "with nonexistent field name" do
+      it "should raise Pdf::NonexistentFieldError" do
+        lambda { @pdf.get_field(:monkey) }.should raise_error(Pdf::NonexistentFieldError, /'monkey' field does not exist in form/)
+      end
+    end
+  end
+
+  describe '#set_field' do
+    it 'should fill the field with given name with given value' do
+      @pdf.set_field(:important_field, "I am important")
+      @pdf.get_field(:important_field).should == "I am important"
+    end
+
+    it 'should return the value written to the field' do
+      @pdf.set_field(:important_field, "I am important").should == 'I am important'
+    end
+
+    it 'should update fields' do
+      @pdf.set_field(:important_field, "I am important")
+      @pdf.fields.should == {
+        :important_field => 'I am important',
+        :unimportant_field => '',
+        :semiimportant_field => '',
+        :tuesday_field => '',
+        :must_not_be_left_blank_field => ''
+      }
+    end
+
+    describe "with existing field name" do
+      it "should not raise an error" do
+        lambda { @pdf.set_field(:important_field, 'I am important') }.should_not raise_error(Pdf::NonexistentFieldError)
+      end
+    end
+
+    describe "with nonexistent field name" do
+      it "should raise Pdf::NonexistentFieldError" do
+        lambda { @pdf.set_field(:monkey, 'Spider') }.should raise_error(Pdf::NonexistentFieldError, /'monkey' field does not exist in form/)
+      end
+    end
+  end
+
+  describe '#set_fields' do
+    it 'should fill the fields with given names with given values' do
+      @pdf.set_fields(@filled_fields)
+      @pdf.get_field(:important_field).should == "I am important"
+      @pdf.get_field(:unimportant_field).should == 'I am unimportant'
+      @pdf.get_field(:semiimportant_field).should == 'I am confused'
+      @pdf.get_field(:tuesday_field).should == 'Is it Tuesday already?'
+      @pdf.get_field(:must_not_be_left_blank_field).should == 'NOT BLANK'
+    end
+
+    it 'should update fields' do
+      @pdf.set_fields(@filled_fields)
+      @pdf.fields.should == @filled_fields
+    end
+
+    it 'should return the set fields' do
+      @pdf.set_fields(@filled_fields).should == @filled_fields
+    end
+
+    describe "with nonexistent field name" do
+      it "should raise Pdf::NonexistentFieldError" do
+        @filled_fields[:monkey] = "spider"
+        lambda { @pdf.set_fields(@filled_fields) }.should raise_error(Pdf::NonexistentFieldError, /'monkey' field does not exist in form/)
+      end
+    end
+  end
+
+  describe '#save_as' do
+    before(:each) do
+      @new_path = File.join(@data_path, 'simple_form_new.pdf')
+      FileUtils.rm_f(@new_path)
+    end
+
+    after(:each) do
+      FileUtils.rm_f(@new_path)
+    end
+
+    it 'should write the pdf to a new path' do
+      @pdf.save_as(@new_path)
+
+      new_pdf = Pdf.new(@new_path)
+      new_pdf.fields.should == {
+        :important_field => '',
+        :unimportant_field => '',
+        :semiimportant_field => '',
+        :tuesday_field => '',
+        :must_not_be_left_blank_field => ''
+      }
+    end
+
+    it 'should save updated fields to the new file' do
+      @pdf.set_field(:important_field, "I am important")
+      @pdf.save_as(@new_path)
+
+      new_pdf = Pdf.new(@new_path)
+      new_pdf.get_field(:important_field).should == "I am important"
+    end
+
+    describe 'given flatten=true' do
+      it 'should save the pdf without a form' do
+        @pdf.save_as(@new_path, true)
+
+        new_pdf = Pdf.new(@new_path)
+        new_pdf.should_not have_form
+      end
+    end
+
+    describe 'with a saved PDF' do
+      before(:each) do
+        @pdf.save_as(@new_path)
+      end
+
+      describe 'saving again' do
+        it "should raise Pdf::ReadOnlyError" do
+          lambda { @pdf.save_as(@new_path) }.should raise_error(Pdf::ReadOnlyError, /Cannot save a previously saved pdf/)
+        end
+      end
+
+      describe "#set_field" do
+        it "should raise Pdf:ReadOnlyError" do
+          lambda { @pdf.set_field(:important_field, 'I am important') }.should raise_error(Pdf::ReadOnlyError, /Previously saved pdfs are read-only/)
+        end
+      end
+
+      describe "#set_fields" do
+        it "should raise Pdf::ReadOnlyError" do
+          lambda { @pdf.set_fields(@filled_fields) }.should raise_error(Pdf::ReadOnlyError, /Previously saved pdfs are read-only/)
+        end
+      end
+    end
+  end
+
+  describe '#has_field?' do
+    describe "with field name as symbol" do
+      it 'should return true if the field exists' do
+        @pdf.has_field?(:important_field).should be(true)
+      end
+
+      it 'should return false if the field does not' do
+        @pdf.has_field?(:monkey).should be(false)
+      end
+    end
+
+    describe "with field name as string" do
+      it 'should return true if the field exists' do
+        @pdf.has_field?("important_field").should be(true)
+      end
+
+      it 'should return false if the field does not' do
+        @pdf.has_field?("monkey").should be(false)
+      end
+    end
+  end
+
+  describe '#has_form?' do
+    describe 'given a pdf with a form' do
+      it 'should return true' do
+        @pdf.should have_form
+      end
+    end
+
+    describe 'given a pdf without a form' do
+      it 'should return false' do
+        pdf = Pdf.new(File.join(@data_path, 'simple_form_flattened.pdf'))
+        pdf.should_not have_form
+      end
+    end
+  end
+
+  describe 'given a pdf that we have flattened' do
+    before(:each) do
+      @new_pdf_path = File.join(@data_path, 'we_flattened.pdf')
+      @pdf.set_fields(@filled_fields)
+      @pdf.save_as(@new_pdf_path, true)
+      @pdf = Pdf.new(@new_pdf_path)
+    end
+
+    after(:each) do
+      FileUtils.rm_f(@new_pdf_path)
+    end
+
+    describe '#flattened_fields' do
+      it 'returns a hash of field name value pairs of previous form fields' do
+        @pdf.flattened_fields.should == @filled_fields
+      end
+    end
+
+    describe '#has_flattened_fields?' do
+      it 'should return true' do
+        @pdf.should have_flattened_fields
+      end
+    end
+  end
+
+  describe 'given a pdf that is not flattened, or we did not flatten' do
+    before(:each) do
+      @pdf = Pdf.new(File.join(@data_path, 'simple_form_flattened.pdf'))
+    end
+
+    describe '#flattened_fields' do
+      it 'should return an empty hash' do
+        @pdf.flattened_fields.should == {}
+      end
+    end
+
+    describe '#has_flattened_fields' do
+      it 'should be false' do
+        @pdf.should_not have_flattened_fields
+      end
+    end
+  end
+
+  # set_field returns some error if the form field is incorrect (e.g. setting a checkbox with something silly like 'monkey' or 'true' instead of 'Yes'
+  # save_as returns *UNTESTED* if the PDF form is not valid
+end
+
+end

data/spec/lib/jpdfer/pdf_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+
+module Jpdfer
+# IMPORTANT: These are model/unit specs! Test in isolation as much as possible!
+describe Pdf do
+  before(:each) do
+    @data_path = File.join(ROOT, 'spec', 'data')
+    @pdf_path = File.join(@data_path, 'simple_form.pdf')
+    @pdf = Pdf.new(@pdf_path)
+  end
+
+  describe '.new' do
+    it 'should create new pdf' do
+      @pdf.should_not be_nil
+    end
+  end
+end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+# spec_helper.rb
+require 'jpdfer'
+require 'fileutils'

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: jpdfer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.3.1
+platform: java
+authors: 
+  - Scott Nielsen
+  - David Brady
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-21 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: nokogiri
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: json-jruby
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id003
+description: Ruby-style wrapper in JRuby for reading and writing PDF forms
+email: scottnielsen5@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - README.rdoc
+  - jars/bcmail-jdk16-146.jar
+  - jars/bcprov-jdk16-146.jar
+  - jars/bctsp-jdk16-146.jar
+  - jars/itextpdf-5.1.1.jar
+  - lib/jpdfer.rb
+  - lib/jpdfer/key_store.rb
+  - lib/jpdfer/page_sizes.rb
+  - lib/jpdfer/pdf.rb
+  - lib/jpdfer/version.rb
+  - spec/spec_helper.rb
+  - spec/acceptance/jpdfer/pdf_acceptance_spec.rb
+  - spec/lib/jpdfer/pdf_spec.rb
+  - spec/data/keystore.ks
+  - spec/data/flattened.pdf
+  - spec/data/simple_form.pdf
+  - spec/data/simple_form_flattened.pdf
+  - spec/data/simple_form_flattened_signed.pdf
+  - spec/data/simple_form_signed_by_someone_else.pdf
+homepage: http://github.com/scizo/jpdfer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.rdoc
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Read and write PDF forms in JRuby
+test_files: 
+  - spec/spec_helper.rb
+  - spec/acceptance/jpdfer/pdf_acceptance_spec.rb
+  - spec/lib/jpdfer/pdf_spec.rb
+  - spec/data/keystore.ks
+  - spec/data/flattened.pdf
+  - spec/data/simple_form.pdf
+  - spec/data/simple_form_flattened.pdf
+  - spec/data/simple_form_flattened_signed.pdf
+  - spec/data/simple_form_signed_by_someone_else.pdf