gjman 0.1.0

data/lib/gjman/pdf/utils/pdfc.rb

@@ -0,0 +1,52 @@
+module Gjman
+  module PDF
+    module Utils
+      module PDFC
+
+        class NotSupportedServiceError < Exception ; end
+
+        SERVICE = 'com.inet.pdfc.PDFC'
+        JARS = %w{CCLib log4j-1.2.15 PDFC PDFParser}.map{|n| Gjman.ext('pdfc',"#{n}.jar") }.join(':')
+        Gjman::JAVA_LIBS << JARS
+
+        module JRuby
+          def method_missing(mode, *args)
+            Gjman::JRuby.sandbox do
+              service, args = extract_args(mode, args)
+              Gjman::JRuby.classify(service).main(args.split(' '))
+            end
+          end
+        end
+
+        module Rjb
+          def method_missing(mode, *args)
+            Gjman::Rjb.sandbox do
+              service, args = extract_args(mode, args)
+              Gjman::Rjb.classify(service).main(args.split(' '))
+            end
+          end
+        end
+
+        module Shell
+          def method_missing(mode, *args)
+            service, args = extract_args(mode, args)
+            @cmd ||= 'java -cp %s %s' % [JARS, service]
+            %x|#{@cmd} #{args} 2>&1|
+          end
+        end
+
+        def self.extract_args(mode, args)
+          raise NotSupportedServiceError unless mode == :diff
+          [
+            SERVICE,
+            [args].flatten.compact.join(' ')
+          ]
+        end
+
+        extend const_get(Gjman::JAVA_MODE)
+
+      end
+    end
+  end
+end
+

data/lib/gjman/rjb.rb

@@ -0,0 +1,32 @@
+module Gjman
+  module Rjb
+    class << self
+
+      def initialize
+        @initialized ||= (
+          ::Rjb::load([Gjman::JAVA_LIBS, Gjman.root('gjman','java_hacks')].flatten.join(':'))
+          @forbid_system_exit = classify('ForbidSystemExit')
+          @forbid_system_exit_error = @forbid_system_exit.class.const_get(:Exception)
+          true
+        )
+      end
+
+      def classify(klass)
+        ::Rjb.import(klass)
+      end
+
+      def sandbox(&block)
+        initialize
+        begin
+          @forbid_system_exit.apply
+          @result = yield
+        rescue @forbid_system_exit_error
+          @result
+        ensure
+          @forbid_system_exit.unapply
+        end
+      end
+
+    end
+  end
+end

data/spec/generic/file_system_spec.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+module Gjman::FileSystem
+  class << self
+    def trashable_tmp_files
+      @trashable_tmp_files ||= []
+    end
+  end
+end
+
+describe 'Gjman::FileSystem (ensuring file exists)' do
+
+  before do
+    @missing_file = "#{__FILE__}.x"
+    @check_test_passes_and_completes_in_n_secs = lambda do |seconds_to_wait, test_proc|
+      started_at = Time.now
+      test_proc.call
+      (Time.now - started_at).to_i.should.equal seconds_to_wait
+    end
+  end
+
+  describe '> when given N seconds to wait' do
+
+    it 'should wait & raise Gjman::FileNotFoundError if file eventually does not exist' do
+      @check_test_passes_and_completes_in_n_secs[
+        seconds_to_wait = 2, lambda do
+          lambda { Gjman::FileSystem.file_must_exist!(@missing_file, seconds_to_wait) }.
+            should.raise(Gjman::FileNotFoundError).
+            message.should.equal("File '#{@missing_file}' not found.")
+        end
+      ]
+    end
+
+    it 'should wait & not raise Gjman::FileNotFoundError if file eventually exists' do
+      # Hmm ... don't really know how to test this yet.
+      true.should.be.true
+    end
+
+  end
+
+  describe '> when not given any seconds to wait' do
+
+    it 'should immediately raise Gjman::FileNotFoundError if file does not exist' do
+      @check_test_passes_and_completes_in_n_secs[
+        seconds_to_wait = 0, lambda do
+          lambda { Gjman::FileSystem.file_must_exist!(@missing_file) }.
+            should.raise(Gjman::FileNotFoundError).
+            message.should.equal("File '#{@missing_file}' not found.")
+        end
+      ]
+    end
+
+    it 'should not raise Gjman::FileNotFoundError if file exists' do
+      @check_test_passes_and_completes_in_n_secs[
+        seconds_to_wait = 0,
+        lambda { Gjman::FileSystem.file_must_exist!(__FILE__) }
+      ]
+    end
+
+  end
+
+end
+
+describe 'Gjman::FileSystem (trashable temp files)' do
+
+  it 'should always return a new temp file upon request' do
+    (file = Gjman::FileSystem.tmp_file).class.should.equal Tempfile
+  end
+
+  it 'should support customizing of name of requested temp file' do
+    (file = Gjman::FileSystem.tmp_file('zzyyxx')).class.should.equal Tempfile
+    file.path.should.match(/zzyyxx/)
+  end
+
+  it 'should cache newly requested temp file' do
+    orig_count = Gjman::FileSystem.trashable_tmp_files.size
+    file = Gjman::FileSystem.tmp_file
+    Gjman::FileSystem.trashable_tmp_files.size.should.equal orig_count.succ
+    file.path.should.equal Gjman::FileSystem.trashable_tmp_files[-1].path
+  end
+
+  it 'should support trashing/deleting all previously requested temp files' do
+    (0..1).each {|_| Gjman::FileSystem.tmp_file }
+    orig_count = Gjman::FileSystem.trashable_tmp_files.size
+    Gjman::FileSystem.trash_tmp_files
+    Gjman::FileSystem.trashable_tmp_files.should.be.empty
+  end
+
+end
+
+describe 'Gjman::FileSystem (tmp dir)' do
+
+  it 'should remove tmp dir after block execution' do
+    tmp_dir = nil
+    Gjman::FileSystem.tmp_dir{|dir| tmp_dir = dir }
+    tmp_dir.should.not.be.nil
+    File.exists?(tmp_dir).should.be.false
+  end
+
+end

data/spec/generic/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'gjman'

data/spec/pdf/compressor_spec.rb

@@ -0,0 +1,114 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Gjman::PDF as compressor" do
+
+  after do
+    trash_tmp_files
+  end
+
+  shared 'uncompressing' do
+
+    should 'not uncompress when pdf is uncompressed' do
+      @should_reflect_uncompressed_size[:uncompressed]
+    end
+
+    should 'uncompress when pdf is compressed' do
+      @should_reflect_uncompressed_size[:uncompressed]
+    end
+
+    should 'return uncompressed file path' do
+      @should_return_uncompressed_file_path[:uncompressed]
+    end
+
+  end
+
+  describe '>> uncompressing (w specified dest file)' do
+
+    before do
+      @should_reflect_uncompressed_size = lambda do |name|
+        uncompressed_file = Gjman::PDF.uncompress(data_file(name), :to => tmp_file('uncompressed').path)
+        uncompressed_file.should.be equal_in_size_as(data_file(:uncompressed))
+        uncompressed_file.should.be bigger_in_size_than(data_file(:compressed))
+      end
+      @should_return_uncompressed_file_path = lambda do |name|
+        expected_return_file = tmp_file('uncompressed').path
+        Gjman::PDF.uncompress(data_file(name), :to => expected_return_file).
+          should.equal(expected_return_file)
+      end
+    end
+
+    behaves_like 'uncompressing'
+
+  end
+
+  describe '>> uncompressing (wo specified dest file)' do
+
+    before do
+      @should_reflect_uncompressed_size = lambda do |name|
+        uncompressed_file = Gjman::PDF.uncompress(data_file(name))
+        uncompressed_file.should.be equal_in_size_as(data_file(:uncompressed))
+        uncompressed_file.should.be bigger_in_size_than(data_file(:compressed))
+      end
+      @should_return_uncompressed_file_path = lambda do |name|
+        expected_return_file = data_file(name).sub(/\.pdf$/,'-u.pdf')
+        Gjman::PDF.uncompress(data_file(name)).should.equal(expected_return_file)
+      end
+    end
+
+    behaves_like 'uncompressing'
+
+  end
+
+  shared 'compressing' do
+
+    should 'not compress when pdf is compressed' do
+      @should_reflect_compressed_size[:compressed]
+    end
+
+    should 'compress when pdf is uncompressed' do
+      @should_reflect_compressed_size[:uncompressed]
+    end
+
+    should 'return compressed file path' do
+      @should_return_compressed_file_path[:compressed]
+    end
+
+  end
+
+  describe '>> compressing (w specified dest file)' do
+
+    before do
+      @should_reflect_compressed_size = lambda do |name|
+        compressed_file = Gjman::PDF.compress(data_file(name), :to => tmp_file('compressed').path)
+        compressed_file.should.be equal_in_size_as(data_file(:compressed))
+        compressed_file.should.be smaller_in_size_than(data_file(:uncompressed))
+      end
+      @should_return_compressed_file_path = lambda do |name|
+        expected_return_file = tmp_file('compressed').path
+        Gjman::PDF.compress(data_file(name), :to => expected_return_file).should.equal(expected_return_file)
+      end
+    end
+
+    behaves_like 'compressing'
+
+  end
+
+  describe '>> compressing (wo specified dest file)' do
+
+    before do
+      @should_reflect_compressed_size = lambda do |name|
+        compressed_file = Gjman::PDF.compress(data_file(name))
+        compressed_file.should.be equal_in_size_as(data_file(:compressed))
+        compressed_file.should.be smaller_in_size_than(data_file(:uncompressed))
+      end
+      @should_return_compressed_file_path = lambda do |name|
+        expected_return_file = data_file(name).sub(/\.pdf$/,'-o.pdf')
+        Gjman::PDF.compress(data_file(name)).should.equal(expected_return_file)
+      end
+    end
+
+    behaves_like 'compressing'
+
+  end
+
+end

data/spec/pdf/matcher_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Gjman::PDF as matcher" do
+
+  have_matching_content = lambda do |name1, name2|
+    Gjman::PDF.match?(data_file(name1), data_file(name2))
+  end
+
+  describe "> matching pdfs (with text content)" do
+
+    should 'return false if pdfs have different texts' do
+      have_matching_content[:text_x1, :text_y1].should.be.false
+    end
+
+    should 'return true if pdfs have identical texts' do
+      have_matching_content[:text_x1, :text_x2].should.be.true
+    end
+
+    should 'return false if pdfs have identical texts, but positioned differently' do
+      have_matching_content[:text_y1, :text_y2_diff_pos].should.be.false
+    end
+
+    should 'return false if pdfs have identical texts, but sized differently' do
+      have_matching_content[:text_y1, :text_y3_diff_size].should.be.false
+    end
+
+    should 'return false if pdfs have identical texts, but with different fonts' do
+      have_matching_content[:text_y1, :text_y4_diff_font].should.be.false
+    end
+
+    should 'return false if pdfs have identical texts, but with different styles' do
+      have_matching_content[:text_y1, :text_y5_diff_style].should.be.false
+    end
+
+    should 'return false if pdfs have identical texts, but with different colors' do
+      have_matching_content[:text_y1, :text_y6_diff_color].should.be.false
+    end
+
+    should 'return false if pdfs have identical texts, but with different backgrounds' do
+      have_matching_content[:text_y1, :text_y7_diff_bg].should.be.false
+    end
+
+  end
+
+  describe '> matching pdfs (with picture content)' do
+
+    should 'return false if pdfs have different images' do
+      have_matching_content[:picture_x1, :picture_y1].should.be.false
+    end
+
+    should 'return true if pdfs have identical images' do
+      have_matching_content[:picture_x1, :picture_x2].should.be.true
+    end
+
+    should 'return false if pdfs have identical images, but positioned differently' do
+      have_matching_content[:picture_x1, :picture_x3_diff_pos].should.be.false
+    end
+
+    should 'return false if pdfs have identical images, but sized differently' do
+      have_matching_content[:picture_x1, :picture_x4_diff_size].should.be.false
+    end
+
+  end
+
+end

data/spec/pdf/merger_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Gjman::PDF as merger" do
+
+  after do
+    trash_tmp_files
+  end
+
+  describe '>> merging' do
+
+    before do
+      @src_files = %w{page1 page2 page3}.map{|name| data_file(name) }
+    end
+
+    should 'merge pdfs to specified file when given {:to => FILE}' do
+      merged_file = Gjman::PDF.merge(*[@src_files, {:to => tmp_file('merged').path}].flatten)
+      merged_file.should.be equal_in_size_as(data_file(:merged_pages))
+    end
+
+    should 'merge pdfs to default *-m.pdf when not given {:to => FILE}' do
+      merged_file = Gjman::PDF.merge(*@src_files)
+      merged_file.should.be equal_in_size_as(data_file(:merged_pages))
+    end
+
+  end
+
+end

data/spec/pdf/spec_helper.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'gjman/pdf'
+
+def data_file(name)
+  File.join(File.expand_path(File.dirname(__FILE__)), 'data', "#{name}.pdf")
+end
+
+def having_same_content_as(file_or_id)
+  expected_file = file_or_id.is_a?(Symbol) ? data_file(file_or_id) : file_or_id
+  lambda do |subject_file|
+    (File.readlines(subject_file).join <=> File.readlines(expected_file).join).zero?
+  end
+end