pdf_editor 0.0.1

data/lib/pdf_editor/rotate_page.rb

@@ -0,0 +1,69 @@
+require_relative 'resource'
+require_relative 'mixins/service'
+require_relative 'mixins/pdf_runner'
+require_relative 'mixins/errors'
+
+module PdfEditor
+  class RotatePage
+    include PdfEditor::Service
+    include PdfEditor::PdfRunner
+    include PdfEditor::Errors
+
+    ROTATIONS = {
+      left:   'left',
+      right:  'right',
+      flip:   'down'
+    }
+
+    attr_reader :resource, :page, :rotate
+
+    def post_init
+      @resource   = args.fetch(:resource, nil)
+      @page       = args.fetch(:page, nil)
+      @rotate     = ROTATIONS[args.fetch(:rotate, '')]
+    end
+
+    def call
+      if resource.nil? || page.nil? || rotate.nil?
+        raise Errors::ArgumentMissingError, 
+              "resource: #{resource} \n page: #{page} \n rotate: #{rotate}"
+      end
+      PdfEditor::Resource.new(
+        create_tempfile {run_command}
+      )
+    end
+
+    private
+
+    def run_command
+      read_from_io do 
+        pdf_runner.cat(format_command)
+      end
+    end
+
+    def get_page_count
+      page_count = resource.page_count
+      if page_count == 0 || page > page_count
+        raise Errors::PageRangeError, "Page #{page} does not exist. There are #{page_count} pages "
+      end
+      page_count
+    end
+
+    def format_command
+      page_count = get_page_count
+      page_nums  = Array(1..page_count)
+
+      before_page = page_nums[0, page_nums.index(page)]
+
+      first_page_after = page_nums.index(page+1) || page_nums.length
+      after_page = page_nums[first_page_after, page_nums.length]
+
+      result = []
+      result << {:pdf => resource.path, :start => before_page.first, :end => before_page.last} unless before_page.empty?
+      result << {:pdf => resource.path, :start => page, :end => page, :orientation => rotate}
+      result << {:pdf => resource.path, :start => after_page.first, :end => after_page.last} unless after_page.empty?
+      result
+    end
+
+  end
+end

data/lib/pdf_editor/shuffle.rb

@@ -0,0 +1,58 @@
+require_relative 'resource'
+require_relative 'mixins/service'
+require_relative 'mixins/pdf_runner'
+require_relative 'mixins/errors'
+
+module PdfEditor
+  class Shuffle
+    include PdfEditor::Service
+    include PdfEditor::PdfRunner
+    include PdfEditor::Errors
+
+    #
+    # Page order does not require unique members and
+    # is not sorted. This is the base class for other
+    # shuffle operations.
+    #
+
+    attr_reader :resource, :page_order
+
+    def post_init
+      @resource   = args[:resource]
+      @page_order = args.fetch(:page_order, [])
+    end
+
+    def call
+      if resource.nil?
+        raise Errors::ResourcesEmptyError, 'Must have a resource to shuffle'
+      end
+      if page_order.empty?
+        raise Errors::PageOrderInvalidError, 'Page order was invalid'
+      end
+      PdfEditor::Resource.new(
+        create_tempfile {run_command}
+      )
+    end
+
+    private 
+
+    def run_command
+      read_from_io do 
+        pdf_runner.cat(format_command)
+      end
+    rescue ::ActivePdftk::CommandError => e 
+      raise InvalidInputError, e.message
+    end
+
+    def format_command
+      page_order.map do |page_num|
+        {
+          :pdf => resource.path, 
+          :start => page_num, 
+          :end => page_num
+        }
+      end
+    end
+
+  end
+end

data/lib/pdf_editor/table_of_contents.rb

@@ -0,0 +1,52 @@
+require_relative 'resource'
+require_relative 'mixins/service'
+require_relative 'mixins/prawn_dsl'
+
+module PdfEditor
+  class TableOfContents
+    include PdfEditor::Service
+    include PdfEditor::PrawnDSL
+
+    attr_reader :resources
+
+    def post_init
+      @resources = args.fetch(:resources, [])
+    end
+
+    def call
+      if resources.empty?
+        raise PdfEditor::Errors::ResourcesEmptyError, 
+              'You must have at least one resource to create a table of contents'
+      end
+      PdfEditor::Resource.new(
+        create_tempfile {create_pdf}
+      )
+    end
+
+    def create_pdf
+      update_pdf do 
+        header
+        body
+      end
+      to_pdf
+    end
+
+    def header
+      move_down 20
+      text 'applicant_name', size: 40, align: :center
+      move_down 50
+    end
+
+    def body
+      begin_page_count = 1 # TOC normally doesn't count itself as a page
+
+      resources.inject(begin_page_count) do |page_location, resource|
+        text "#{resource.name}........................#{page_location}"
+        move_down 10 
+
+        page_location + resource.page_count 
+      end
+    end
+
+  end
+end

data/lib/pdf_editor/title_page.rb

@@ -0,0 +1,38 @@
+require_relative 'resource'
+require_relative 'mixins/service'
+require_relative 'mixins/prawn_dsl'
+
+module PdfEditor
+  class TitlePage
+    include PdfEditor::Service
+    include PdfEditor::PrawnDSL
+    include PdfEditor::Errors
+
+    attr_reader :title 
+
+    def post_init
+      @title = args[:title]
+    end
+
+    def call
+      unless title
+        raise Errors::TitlePageTitleError, 'Title page requires a title to operate'
+      end
+      PdfEditor::Resource.new(
+        create_tempfile {create_pdf}, 
+        title
+      )
+    end
+
+    private
+
+    def create_pdf
+      update_pdf do 
+        move_down 30
+        text title, size: 40, align: :center
+      end
+      to_pdf
+    end
+
+  end
+end

data/lib/pdf_editor/version.rb

@@ -0,0 +1,3 @@
+module PdfEditor
+  VERSION = "0.0.1"
+end

data/pdf_editor.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pdf_editor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pdf_editor"
+  spec.version       = PdfEditor::VERSION
+  spec.authors       = ["bradwheel"]
+  spec.email         = ["bradley.m.wheel@gmail.com"]
+  spec.summary       = %q{Edits Pdf's}
+  spec.description   = %q{Edits Pdf's}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'prawn',         '1.2.1'
+  spec.add_dependency 'pdf-reader',    '1.3.3'
+  spec.add_dependency 'docsplit',      '0.7.5'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pdf-inspector'
+  spec.add_development_dependency 'pry'
+end

data/spec/bundle_spec.rb

@@ -0,0 +1,158 @@
+require 'support/spec_helper'
+
+module PdfEditor
+  describe Bundle do 
+
+    before do 
+      @resource_1 = get_resource('five_page.pdf', 'Five Page Pdf')
+      @resource_2 = get_resource('two_page.pdf', 'Two Page Pdf')
+      @service = PdfEditor::Bundle.new(
+        resources: [@resource_1, @resource_2], 
+        title: 'TOC', 
+        with_toc: true, 
+        with_title_pages: true
+      )
+    end
+
+    describe '#create_title_page' do 
+
+      it 'returns a resource' do 
+        ret = @service.send(:create_title_page, @resource_1)
+        expect(ret).to be_instance_of PdfEditor::Resource
+      end
+      
+    end
+
+    describe '#merge_resource_with_title_page' do 
+
+      it 'creates a single resource with title page and original content' do 
+        ret = @service.send(:merge_resource_with_title_page, @resource_1)
+        contents = []
+        ret.open_file do |f|
+          reader = ::PDF::Reader.new(f)
+          reader.pages.each {|page| contents << page.text}
+        end
+        expect(ret.page_count).to eq 6
+        expect(contents).to eq ['Five Page Pdf', 'Page 1', 'Page 2', 'Page 3', 'Page 4', 'Page 5']
+      end
+
+    end
+
+    describe '#call' do 
+
+      before do 
+        @service.stub(:create_title_pages) { nil }
+        @service.stub(:create_table_of_contents) { nil }
+        @service.stub(:bundle_documents) { nil }
+      end
+
+      it 'calls #create_title_pages' do 
+        expect(@service).to receive(:create_title_pages)
+        @service.call
+      end
+
+      it 'calls #create_table_of_contents' do 
+        expect(@service).to receive(:create_table_of_contents)
+        @service.call
+      end
+
+      it 'calls #bundle_documents' do 
+        expect(@service).to receive(:bundle_documents)
+        @service.call 
+      end
+
+    end
+
+    describe '#create_title_pages' do 
+
+      context 'when with_title_pages' do 
+
+        it 'creates title pages' do 
+          service = PdfEditor::Bundle.new(
+            resources: [@resource_1, @resource_2], 
+            title: 'TOC', 
+            with_toc: true, 
+            with_title_pages: true
+          )
+          service.send(:create_title_pages)
+          ready_for_toc = service.send(:ready_for_toc)
+          page_count = ready_for_toc.inject(0) {|sum, resource| sum + resource.page_count}
+          expect(page_count).to eq 9
+        end
+
+      end
+
+      context 'when not with_title_pages' do 
+
+        it 'does not create title pages' do 
+          service = PdfEditor::Bundle.new(
+            resources: [@resource_1, @resource_2], 
+            title: 'TOC', 
+            with_toc: true, 
+            with_title_pages: false
+          )
+          service.send(:create_title_pages)
+          ready_for_toc = service.send(:ready_for_toc)
+          page_count = ready_for_toc.inject(0) {|sum, resource| sum + resource.page_count}
+          expect(page_count).to eq 7
+        end
+
+      end
+
+    end
+
+    describe '#create_table_of_contents' do 
+
+      it 'does nothing if ready_for_toc is empty' do
+        service = PdfEditor::Bundle.new(
+          resources: [], 
+          title: 'TOC', 
+          with_toc: true, 
+          with_title_pages: false
+        )
+        service.send(:create_table_of_contents)
+        expect(service.send(:table_of_contents)).to be_nil
+      end
+
+      it 'does nothing if not with_toc' do
+        service = PdfEditor::Bundle.new(
+          resources: [@resource_1, @resource_2], 
+          title: 'TOC', 
+          with_toc: false, 
+          with_title_pages: false
+        )
+        service.send(:create_table_of_contents)
+        expect(service.send(:table_of_contents)).to be_nil
+      end
+
+      it 'sets table_of_contents to generated table_of_contents' do 
+        service = PdfEditor::Bundle.new(
+          resources: [@resource_1, @resource_2], 
+          title: 'TOC', 
+          with_toc: true, 
+          with_title_pages: true
+        )
+        service.stub(:ready_for_toc) {[@resource_1, @resource_2]}
+        service.send(:create_table_of_contents)
+        expect(service.send(:table_of_contents)).to be_instance_of PdfEditor::Resource
+      end
+
+    end
+
+    describe '#bundle_documents' do 
+
+      it 'merges the table_of_contents with the contents' do 
+        service = PdfEditor::Bundle.new(
+          resources: [@resource_1, @resource_2], 
+          title: 'TOC', 
+          with_toc: true, 
+          with_title_pages: true
+        )
+        ret = service.call
+        expect(ret.page_count).to eq 10
+      end
+
+    end
+
+  end
+end

data/spec/merge_spec.rb

@@ -0,0 +1,63 @@
+require 'support/spec_helper'
+
+module PdfEditor
+  describe Merge do 
+
+    before do 
+      support_dir = ::File.join(::File.dirname(__FILE__), 'support', 'docs')
+
+      ['merge_1.pdf', 'merge_2.pdf'].each_with_index do |file, i|
+        
+        ::File.open(::File.join(support_dir, file), 'r') do |f|
+          
+          ::Tempfile.open(['', '.pdf']) do |tf|
+            tf.write f.read 
+            instance_variable_set(:"@resource_#{i+1}", PdfEditor::Resource.new(tf))
+          end
+
+        end
+
+      end
+    end
+
+    describe '#call' do 
+
+      before do 
+        @ret = PdfEditor::Merge.call(resources: [@resource_1, @resource_2], merged_name: 'Merged Name')
+      end
+
+      it 'returns a resource' do 
+        expect(@ret).to be_instance_of PdfEditor::Resource 
+      end
+
+      it 'returns a merged document' do
+        contents = ''
+        @ret.open_file do |f|
+          PDF::Reader.new(f).pages.each {|page| contents << page.text}
+        end
+        expect(contents).to eq 'merge 1merge 2'
+        expect(@ret.page_count).to eq 2
+      end
+
+      it 'raises an error if no resources are present' do 
+        expect{PdfEditor::Merge.call}.to raise_error PdfEditor::Errors::ResourcesEmptyError
+      end
+
+      it 'returned resource has merged_name if supplied' do 
+        expect(@ret.name).to eq 'Merged Name'
+      end
+
+    end
+
+    describe '#format_command' do 
+
+      it 'creates the proper format for merge' do 
+        expected_format = [{:pdf => @resource_1.path}, {:pdf => @resource_2.path}]
+        service = PdfEditor::Merge.new(resources: [@resource_1, @resource_2])
+        expect(service.send(:format_command)).to eq expected_format
+      end
+
+    end
+
+  end
+end