poppler 3.1.8-x64-mingw32 → 3.1.9-x64-mingw32

data/extconf.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'pathname'
-require 'mkmf'
-require 'rbconfig'
-require 'fileutils'
-
-package = "poppler"
-
-base_dir = Pathname(__FILE__).dirname.expand_path
-ext_dir = base_dir + "ext" + package
-mkmf_gnome2_dir = base_dir + 'lib'
-
-ruby = File.join(RbConfig::CONFIG['bindir'],
-                 RbConfig::CONFIG['ruby_install_name'] +
-                 RbConfig::CONFIG["EXEEXT"])
-
-build_dir = Pathname("ext") + package
-FileUtils.mkdir_p(build_dir.to_s) unless build_dir.exist?
-extconf_rb_path = ext_dir + "extconf.rb"
-system(ruby, "-C", build_dir.to_s, extconf_rb_path.to_s, *ARGV) || exit(false)
-
-create_makefile(package)
-FileUtils.mv("Makefile", "Makefile.lib")
-
-File.open("Makefile", "w") do |makefile|
-  makefile.puts(<<-EOM)
-all:
-	(cd ext/#{package} && $(MAKE))
-	$(MAKE) -f Makefile.lib
-
-install:
-	(cd ext/#{package} && $(MAKE) install)
-	$(MAKE) -f Makefile.lib install
-
-site-install:
-	(cd ext/#{package} && $(MAKE) site-install)
-	$(MAKE) -f Makefile.lib site-install
-
-clean:
-	(cd ext/#{package} && $(MAKE) clean)
-	$(MAKE) -f Makefile.lib clean
-
-distclean:
-	(cd ext/#{package} && $(MAKE) distclean)
-	$(MAKE) -f Makefile.lib distclean
-	@rm -f Makefile.lib
-EOM
-end

data/test/test_annotation.rb

@@ -1,86 +0,0 @@
-class TestAnnotation < Test::Unit::TestCase
-  def test_type
-    only_poppler_version(0, 7, 2)
-    assert_kind_of(Poppler::AnnotationType, annotation.type)
-  end
-
-  def test_contents
-    only_poppler_version(0, 7, 2)
-    assert_nil(annotation.contents)
-  end
-
-  def test_name
-    only_poppler_version(0, 7, 2)
-    assert_nil(annotation.name)
-  end
-
-  def test_modified
-    only_poppler_version(0, 7, 2)
-    assert_nil(annotation.modified)
-  end
-
-  def test_flags
-    only_poppler_version(0, 7, 2)
-    assert_kind_of(Poppler::AnnotationFlag, annotation.flags)
-  end
-
-  def test_color
-    only_poppler_version(0, 7, 2)
-    assert_nil(annotation.color)
-  end
-
-  def test_markup
-    only_poppler_version(0, 7, 2)
-    # We don't have a PDF that has annotation markup...
-    assert_method_defined(Poppler::AnnotationMarkup, :label)
-    assert_method_defined(Poppler::AnnotationMarkup, :popup_is_open?)
-    assert_method_defined(Poppler::AnnotationMarkup, :opacity)
-    assert_method_defined(Poppler::AnnotationMarkup, :date)
-    assert_method_defined(Poppler::AnnotationMarkup, :subject)
-    assert_method_defined(Poppler::AnnotationMarkup, :reply_to)
-    assert_method_defined(Poppler::AnnotationMarkup, :external_data)
-  end
-
-  def test_text
-    only_poppler_version(0, 7, 2)
-    # We don't have a PDF that has annotation text...
-    assert_method_defined(Poppler::AnnotationText, :open?)
-    assert_method_defined(Poppler::AnnotationText, :icon)
-    assert_method_defined(Poppler::AnnotationText, :state)
-  end
-
-  def test_free_text
-    only_poppler_version(0, 7, 2)
-    # We don't have a PDF that has annotation free text...
-    assert_method_defined(Poppler::AnnotationFreeText, :quadding)
-    assert_method_defined(Poppler::AnnotationFreeText, :callout_line)
-  end
-
-  def test_callout_line
-    only_poppler_version(0, 7, 2)
-    callout_line = Poppler::AnnotationCalloutLine.new(true,
-                                                      1.1, 2.2, 3.3,
-                                                      4.4, 5.5, 6.6)
-    assert(callout_line.multiline?)
-    assert_equal(1.1, callout_line.x1)
-    assert_equal(2.2, callout_line.y1)
-    assert_equal(3.3, callout_line.x2)
-    assert_equal(4.4, callout_line.y2)
-    assert_equal(5.5, callout_line.x3)
-    assert_equal(6.6, callout_line.y3)
-    assert_equal([true, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6], callout_line.to_a)
-  end
-
-  private
-  def annotation
-    document = Poppler::Document.new(form_pdf)
-    page = document[0]
-    page.annotation_mapping[0].annotation
-  end
-
-  def assert_method_defined(object, method)
-    assert do
-      object.method_defined?(method)
-    end
-  end
-end

data/test/test_constants.rb

@@ -1,30 +0,0 @@
-class TestConstants < Test::Unit::TestCase
-  def test_annotation
-    if later_version?(0, 7, 2)
-      assertion = :assert_const_defined
-    else
-      assertion = :assert_not_const_defined
-    end
-    send(assertion, Poppler, :AnnotationType)
-    if assertion == :assert_const_defined
-      assert_equal("3d", Poppler::AnnotationType::TYPE_3D.nick)
-    end
-    send(assertion, Poppler, :AnnotationFlag)
-    send(assertion, Poppler, :AnnotationMarkupReplyType)
-    send(assertion, Poppler, :AnnotationExternalDataType)
-    if assertion == :assert_const_defined
-      assert_equal("3d", Poppler::AnnotationExternalDataType::TYPE_3D.nick)
-    end
-    if later_version?(0, 9, 0)
-      assert_not_const_defined(Poppler, :AnnotationTextIcon)
-    else
-      send(assertion, Poppler, :AnnotationTextIcon)
-    end
-    send(assertion, Poppler, :AnnotationTextState)
-    send(assertion, Poppler, :AnnotationFreeTextQuadding)
-  end
-
-  def test_permissions
-    assert_const_defined(Poppler, :Permissions)
-  end
-end

data/test/test_page.rb

@@ -1,51 +0,0 @@
-class TestPage < Test::Unit::TestCase
-  def test_get_image
-    omit("We don't have PDF that has image...")
-    document = Poppler::Document.new(image_pdf)
-    page, mapping = find_first_image_mapping(document)
-    assert_kind_of(Cairo::ImageSurface, page.get_image(mapping.image_id))
-    assert_kind_of(Cairo::ImageSurface, mapping.image)
-  end
-
-  def test_selection_region
-    document = Poppler::Document.new(form_pdf)
-    page = document[0]
-    rectangle = Poppler::Rectangle.new(0, 0, *page.size)
-    region = page.get_selection_region(0.5, :word, rectangle)
-    if later_version?(0, 7, 2)
-      assert_kind_of(Poppler::Rectangle, region[0])
-    else
-      assert_kind_of(Gdk::Region, region)
-    end
-  end
-
-  def test_annotation_mapping
-    only_poppler_version(0, 7, 2)
-    document = Poppler::Document.new(form_pdf)
-    page = document[0]
-    assert_equal([Poppler::AnnotationMapping],
-                 page.annotation_mapping.collect {|mapping| mapping.class}.uniq)
-    mapping = page.annotation_mapping[0]
-    assert_kind_of(Poppler::Rectangle, mapping.area)
-    assert_kind_of(Poppler::Annotation, mapping.annotation)
-  end
-
-  def test_text_layout
-    only_poppler_version(0, 16, 0)
-    document = Poppler::Document.new(form_pdf)
-    page = document[0]
-    layout = page.text_layout
-    assert_equal([60, 31, 79, 60],
-                 layout[0].to_a.collect(&:round))
-  end
-
-  private
-  def find_first_image_mapping(document)
-    document.each do |page|
-      page.image_mapping.each do |mapping|
-        return [page, mapping]
-      end
-    end
-    nil
-  end
-end